leveledit.cpp

一个96K的3D游戏源码

		DrawItemWithCol(MIDead);
		DrawItemWithCol(MISecAttr);
		DrawItemWithCol(MISecAttr2);
		DrawItemWithCol(MISecAttr3);
		DrawItemWithCol(MIBumper);
		DrawItemWithCol(MIPlayer);
		DrawItemWithCol(MIFlamer);
		DrawItemWithCol(MIWater);
		DrawItemWithCol(MISwing);
		DrawItemWithCol(MIMove);
		DrawItemWithCol(MIEnemy1);
		DrawItemWithCol(MIEnemy2);
		DrawItemWithCol(MIEnemy3);
		DrawItemWithCol(MIEnemy4);
		DrawItemWithCol(MIEnemy5);
		DrawItemWithCol(MIBoxGun1);
		DrawItemWithCol(MIBoxMediKit);
		DrawItemWithCol(MIBoxContinue);
		DrawItemWithCol(MIBoxLevEnd);
		DrawItemWithCol(MIBoxGun2);
		DrawItemWithCol(MIPos);
		DrawItemWithCol(MIPosXZ);
		DrawItemWithCol(MIPosY);
	}

	if(MenuMode==_Set_Material)
	{
		DrawItemWithCol(MIMatPlus);
		DrawItemWithCol(MIMatMinus);

		if(Mat[MatNr]->Textured)
		{
			DrawItemWithCol(MITexSize);
			DrawItemWithCol(MITexSizeX);
			DrawItemWithCol(MITexSizeY);
			DrawItemWithCol(MITexSphere);
			DrawItemWithCol(MITexCube);
			DrawItemWithCol(MITexCylinderX);
			DrawItemWithCol(MITexCylinderY);
			DrawItemWithCol(MITexCylinderZ);
		}
		DrawItemWithCol(MIDoIt);
	}

	if(MenuMode==_Modify_Vertex)
	{
		DrawItemWithCol(MIRadiusPlus);
		DrawItemWithCol(MIRadiusMinus);

		DrawItemWithCol(MISubDivsPlus);
		DrawItemWithCol(MISubDivsMinus);

		DrawItemWithCol(MIPos);
		DrawItemWithCol(MIPosXZ);
		DrawItemWithCol(MIPosY);
	}
/*
	if(MenuMode==_Modellieren)
	{
		DrawItemWithCol(MIRadiusPlus);
		DrawItemWithCol(MIRadiusMinus);

		DrawItemWithCol(MIPos);
		DrawItemWithCol(MIPosXZ);
		DrawItemWithCol(MIPosY);

		DrawItemWithCol(MIDoIt);

	}
*/

	DoneText();
}

void DrawCursor(long X,long Y)
{
	InitText();
	glColor3f(1,1,1);
	glPrint(X-8,Y-6,"o");
	DoneText();
}

void DrawEcke(float si,float R,float G,float B)				// Draw Object Using Requested Width, Height And Texture
{
//	glEnable(GL_TEXTURE_2D);									// Enable Texture MaPPing
//	glBindTexture(GL_TEXTURE_2D, textures[texid].texID);		// Select The Correct Texture
	glBegin(GL_QUADS);											// Start Drawing A Quad
		glColor3f(R,G,B);
		glTexCoord2f(0.0f,0.0f); glVertex3f(-si,-si,si);	// Bottom Left
		glTexCoord2f(1.0f,0.0f); glVertex3f( si,-si,si);	// Bottom Right
		glTexCoord2f(1.0f,1.0f); glVertex3f( si, si,si);	// Top Right
		glTexCoord2f(0.0f,1.0f); glVertex3f(-si, si,si);	// Top Left
		glTexCoord2f(0.0f,0.0f); glVertex3f( si,-si,-si);	// Bottom Left
		glTexCoord2f(1.0f,0.0f); glVertex3f(-si,-si,-si);	// Bottom Right
		glTexCoord2f(1.0f,1.0f); glVertex3f(-si, si,-si);	// Top Right
		glTexCoord2f(0.0f,1.0f); glVertex3f( si, si,-si);	// Top Left

		glTexCoord2f(0.0f,0.0f); glVertex3f(-si,-si,-si);	// Bottom Left
		glTexCoord2f(1.0f,0.0f); glVertex3f(-si,-si,si);	// Bottom Right
		glTexCoord2f(1.0f,1.0f); glVertex3f(-si, si,si);	// Top Right
		glTexCoord2f(0.0f,1.0f); glVertex3f(-si, si,-si);	// Top Left
		glTexCoord2f(0.0f,0.0f); glVertex3f(si,-si,si);	// Bottom Left
		glTexCoord2f(1.0f,0.0f); glVertex3f(si,-si,-si);	// Bottom Right
		glTexCoord2f(1.0f,1.0f); glVertex3f(si, si,-si);	// Top Right
		glTexCoord2f(0.0f,1.0f); glVertex3f(si, si,si);	// Top Left

		glTexCoord2f(0.0f,0.0f); glVertex3f(-si,-si,-si);	// Bottom Left
		glTexCoord2f(1.0f,0.0f); glVertex3f(si,-si,-si);	// Bottom Right
		glTexCoord2f(1.0f,1.0f); glVertex3f(si,-si,si);	// Top Right
		glTexCoord2f(0.0f,1.0f); glVertex3f(-si,-si,si);	// Top Left

		glTexCoord2f(0.0f,0.0f); glVertex3f(si,si,-si);	// Bottom Left
		glTexCoord2f(1.0f,0.0f); glVertex3f(-si,si,-si);	// Bottom Right
		glTexCoord2f(1.0f,1.0f); glVertex3f(-si,si,si);	// Top Right
		glTexCoord2f(0.0f,1.0f); glVertex3f(si,si,si);	// Top Left

	glEnd();													// Done Drawing Quad
//	glDisable(GL_TEXTURE_2D);									// Enable Texture MaPPing
}



void DrawGrund(tGrund *Grund,bool Textured,long MatNr,tP3D Mid,tSector *Sector,tP3D ModV)
{
	long I,K,M,OX,OY,II,KK;
	float X1,X2,Y1,Y2,H;
	tWandPoly *Temp;
	tWandVertice *P1,*P2,*P3;
	tP3D V1,V2,V3,V0;
	tMaterial *TempM;

	TempM=Mat[MatNr];

	glLoadIdentity ();													// Reset The Modelview Matrix
	gluLookAt(CPos.X,CPos.Y,CPos.Z,CLook.X,CLook.Y,CLook.Z,0,1,0);
/*
	if(Textured)
		glEnable(GL_TEXTURE_2D);
*/
/*
	glPushMatrix();
	glColor3f(0,1,1);
	glTranslatef(Mid.X,Mid.Y,Mid.Z);
	DrawEcke(0.2,1,1,1);
	glPopMatrix();
*/
//	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set The Texture Generation Mode For S To Sphere Mapping (NEW)
//	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); // Set The Texture Generation Mode For T To Sphere Mapping (NEW)
	glTranslatef(ModV.X,ModV.Y,ModV.Z);
	
	if(Sector==AktSector)
	{
		V0=Sector->Pos;
		V1=vAdd(V0,vMulK(Sector->Matrix.Forward,0.1));
		V2=vAdd(V0,vMulK(Sector->Matrix.Up,0.1));
		V3=vAdd(V0,vMulK(Sector->Matrix.Left,0.1));

		glBegin(GL_LINES);
			glColor3f(1,0,0);
			glVertex3f(V0.X,V0.Y,V0.Z);
			glVertex3f(V1.X,V1.Y,V1.Z);
			glColor3f(0,1,0);
			glVertex3f(V0.X,V0.Y,V0.Z);
			glVertex3f(V2.X,V2.Y,V2.Z);
			glColor3f(0,0,1);
			glVertex3f(V0.X,V0.Y,V0.Z);
			glVertex3f(V3.X,V3.Y,V3.Z);
		glEnd();
	}


	if(Textured)
	{
		if(TempM->Textured)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, textures[TempM->TexNr].texID);	

			glEnable(GL_COLOR_MATERIAL);
			glEnable(GL_LIGHT0);	
			glEnable(GL_LIGHTING);
		} else {
			glEnable(GL_COLOR_MATERIAL);
			glEnable(GL_LIGHT0);	
			glEnable(GL_LIGHTING);
		}

	}

	if(Textured)
	{
				glColor3f(1,1,1);
				if(!TempM->Textured) glColor3f(TempM->Color.X,TempM->Color.Y,TempM->Color.Z);
				if(Grund->DisplayListOn)
				{
					glCallList(Grund->DisplayList);
				};
	} else 
	{

	M=1;
	Temp=Grund->Poly;
	while(Temp!=NULL)
	{
		M++;

		P1=Temp->P1;
		P2=Temp->P2;
		P3=Temp->P3;
		if(Textured)
		{	
			if(TempM->Textured)
			{
				glColor3f(1,1,1);
				{

					glBegin(GL_TRIANGLES);
						glNormal3f(P1->Normal.X,P1->Normal.Y,P1->Normal.Z);
						glTexCoord2f(Temp->T1.X,Temp->T1.Y); 
						glVertex3f(P1->WorldPos.X,P1->WorldPos.Y,P1->WorldPos.Z);
						glNormal3f(P2->Normal.X,P2->Normal.Y,P2->Normal.Z);
						glTexCoord2f(Temp->T2.X,Temp->T2.Y); 
						glVertex3f(P2->WorldPos.X,P2->WorldPos.Y,P2->WorldPos.Z);
						glNormal3f(P3->Normal.X,P3->Normal.Y,P3->Normal.Z);
						glTexCoord2f(Temp->T3.X,Temp->T3.Y); 
						glVertex3f(P3->WorldPos.X,P3->WorldPos.Y,P3->WorldPos.Z);
					glEnd();

				}
			} else {
				glColor3f(TempM->Color.X,TempM->Color.Y,TempM->Color.Z);
				glBegin(GL_TRIANGLES);
					glNormal3f(P1->Normal.X,P1->Normal.Y,P1->Normal.Z);
					glVertex3f(P1->WorldPos.X,P1->WorldPos.Y,P1->WorldPos.Z);
					glNormal3f(P2->Normal.X,P2->Normal.Y,P2->Normal.Z);
					glVertex3f(P2->WorldPos.X,P2->WorldPos.Y,P2->WorldPos.Z);
					glNormal3f(P3->Normal.X,P3->Normal.Y,P3->Normal.Z);
					glVertex3f(P3->WorldPos.X,P3->WorldPos.Y,P3->WorldPos.Z);
				glEnd();
			}

		} else {
			glBegin(GL_LINES);

			glColor3f(0.7,0.7,0.7);
			if(DrawNr==ASNr) glColor3f(1,1,1);
			if(IsAChildOf(GetSubSectorNr(Level,DrawNr),GetSubSectorNr(Level,ASNr))) glColor3f(0.9,0.9,0.7);
			if(DrawNr==SelO) glColor3f(1,0.5,0);

			glVertex3f(P1->WorldPos.X,P1->WorldPos.Y,P1->WorldPos.Z);
			glVertex3f(P2->WorldPos.X,P2->WorldPos.Y,P2->WorldPos.Z);
			glVertex3f(P2->WorldPos.X,P2->WorldPos.Y,P2->WorldPos.Z);
			glVertex3f(P3->WorldPos.X,P3->WorldPos.Y,P3->WorldPos.Z);
			glVertex3f(P3->WorldPos.X,P3->WorldPos.Y,P3->WorldPos.Z);
			glVertex3f(P1->WorldPos.X,P1->WorldPos.Y,P1->WorldPos.Z);
		
			glEnd();
		}

		Temp=Temp->Next;
	}
	}
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_LIGHT0);	
	glDisable(GL_LIGHTING);

}



void DrawVerts(tSector *Sector)
{
	long I,K,M,OX,OY,II,KK;
	float Size,L;
	tWandVertice *Temp;
	tP3D V1,V2;


	if(Sector==NULL) return;
	if(Sector->Mesh==NULL) return;

	glLoadIdentity ();													// Reset The Modelview Matrix
	gluLookAt(CPos.X,CPos.Y,CPos.Z,CLook.X,CLook.Y,CLook.Z,0,1,0);


	Size=0.010*vLength2(Sector->Size);
	M=0;
	Temp=Sector->Mesh->Vertice;
	while(Temp!=NULL)
	{
		glLoadName(M);
		glPushMatrix();
		glColor3f(0,1,1);
		glTranslatef(Temp->WorldPos.X,Temp->WorldPos.Y,Temp->WorldPos.Z);
		if(M==AktVertice) {DrawEcke(Size,0,1,0);} else
		if(M==SelV) {DrawEcke(Size,1,0,0);} else
		{
			if((MenuMode==_Modify_Vertex)&&(CamMode==1)&&((L=vLength2(vSub(Temp->WorldPos,GetWandVertice(Sector->Mesh->Vertice,AktVertice)->WorldPos)))<Radius))
			{
				L=0.4+0.4*(1-L/Radius);
				DrawEcke(Size,0,L,0);
			} else 
			{ DrawEcke(Size,1,1,1); }
		}
		glPopMatrix();

		M++;

		Temp=Temp->Next;
	}
	glDisable(GL_TEXTURE_2D);
}

void PickVerts()
{
	long I,K,M,Deep,Num,AnzO;
	tP3D NPos;

	GLint viewport[4];
	GLuint	buffer[512];

	glViewport (0, 0, (GLsizei)(ScreenXSize), (GLsizei)(ScreenYSize));				// Reset The Current Viewport
	glMatrixMode (GL_PROJECTION);										// Select The Projection Matrix
	glLoadIdentity ();													// Reset The Projection Matrix
	gluPerspective (45.0f, (GLfloat)(ScreenXSize)/(GLfloat)(ScreenYSize),			// Calculate The Aspect Ratio Of The Window
					GLViewMin, GLViewMax);		

	glGetIntegerv(GL_VIEWPORT,viewport);
	glSelectBuffer(512,buffer);
	glRenderMode(GL_SELECT);
	glInitNames();
	glPushName(0);
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	gluPickMatrix((GLdouble)MX,(GLdouble) (MY),1.0f,1.0f,viewport);
	gluPerspective(45.0f,(GLfloat) (viewport[2]-viewport[0])/(GLfloat) (viewport[3]-viewport[1]),GLViewMin,GLViewMax);
	glMatrixMode(GL_MODELVIEW);

	DrawVerts(AktSector);

	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);
	AnzO=glRenderMode(GL_RENDER);

	SelV=-1;
	Num=-1;
	if(AnzO>0)
	{
		Num=buffer[3];
		Deep=buffer[1];
		for(I=1;I<AnzO;I++)
		{
			if(buffer[I*4+1]<GLuint(Deep))
			{
				Num=buffer[I*4+3];
				Deep=buffer[I*4+1];
			}
		}	
	}
	SelV=Num;
	if((mouse_klick==1)&&(!MouseAdjust))
	{
		if(SelV!=-1) AktVertice=SelV;
	}
}

void KeyAction(char Key_,bool State)
{
	if((!Key[Key_])&&(State)) KeyPr[Key_]=true;
	Key[Key_]=State;
}

void SetCommand(tCommand *Temp,long Type)
{
	Temp->Type=Type;
}

void StartMouseAdjust()
{
			MouseAdjust=true;
			MAStartX=MX;MAStartY=MY;MAX=0;MAY=0;
}

void Undo()
{
	long I;
	tCommand *Temp;
	if((UndoList[1]==NULL)||(CountCommandList(CommandList)==1)) return;

	DestroySector(Level);
	Level=CopySector(UndoList[1],NULL,true,true);
	for(I=0;I<UndoSteps-1;I++)
	{
		UndoList[I]=UndoList[I+1];
	}
	UndoList[UndoSteps-1]=NULL;

	Temp=CommandList;
	while(Temp->Next->Next!=NULL)
	{
		Temp=Temp->Next;
	}
	DestroyCommand(Temp->Next);
	Temp->Next=NULL;

	AktSector=NULL;
	GetAktSector();
	CreateSectorDL(Level,true);

	if(CountCommandList(CommandList)<=1) MenuMode=_Main_Menu;
	SetResSec(ASNr,Level);
	ResNr=ASNr;
}

void SetAktResSec()
{
	  SetResSec(ASNr,Level);
	  ResNr=ASNr;
}

void RestoreResSec(long Nr)
{
	tSector *SOld,*SNew,*TempO,*TempN,*Temp;

	if(ResSec==NULL) return;
//	SOld=GetSubSectorNr(UndoList[0],Nr);
	SOld=ResSec;
	SNew=GetSubSectorNr(Level,Nr);

//	TempO=SOld->Father->SubSector;
	TempO=ResSec;
	TempN=SNew->Father->SubSector;
//	if(TempO!=SOld)
	if(ResAdd!=0)
	{
		for(long I=0;I<ResAdd-1;I++)
			TempN=TempN->Next;
/*
		while(TempO->Next!=SOld)
		{
			TempO=TempO->Next;
			TempN=TempN->Next;
		}
*/
		Temp=SNew->Next;
		SNew->Next=NULL;
		DestroySector(SNew);
		SNew=CopySector(SOld,TempN->Father,true,false);
		SNew->Next=Temp;
		TempN->Next=SNew;
		CreateSectorDL(SNew,false);
	} else {
//		SOld=SOld->Father;
		SNew=SNew->Father;
		Temp=SNew->SubSector->Next;
		SNew->SubSector->Next=NULL;
		DestroySector(SNew->SubSector);
	    SNew->SubSector=CopySector(SOld,SNew,true,false);
		SNew->SubSector->Next=Temp;
		CreateSectorDL(SNew->SubSector,false);