particlesys.cpp

一个96K的3D游戏源码

		glLoadName(M);
		K=M*1;
		
		glColor3f(1,1,1);
		if((Line+K)->Tag==1) glColor3f(1,0,1);
		if(ShowSplines|((Line+K)->Tag==1))
		{
			glVertex3f((Point+(Line+K)->P1)->X,(Point+(Line+K)->P1)->Y,(Point+(Line+K)->P1)->Z);
			glVertex3f((Point+(Line+K)->P2)->X,(Point+(Line+K)->P2)->Y,(Point+(Line+K)->P2)->Z);
		}
	}
	glEnd();


	InitText();
	glColor3f(1,1,1);
	glPrint(10,460,"F1-FullScreen F2-  F3-LoadModel F4-LoadMensch");
	glPrint(10,440,"F5-ShowSplines F6-SetBasePoint F7-ConvertToModel F8-View");
	glPrint(10,110,"BasePoint: %d",BasePoint);
	glPrint(10,90,"MouseX: %d",mouse_x);
	glPrint(10,70,"MouseY: %d",mouse_y);
	glPrint(10,50,"Screen: %dx%d",ScreenXSize,ScreenYSize);
	glPrint(300,90,"Points: %d",Points);
	glPrint(300,70,"Lines: %d",Lines);
	glPrint(300,50,"SelV: %d",SelV);

	glLoadIdentity();											// Reset The Projection Matrix
	glOrtho(0,ScreenXSize,0,ScreenYSize,1,1);				// Set Up An Ortho Screen
	glMatrixMode(GL_MODELVIEW);									// Select The Modelview Matrix
	glDisable(GL_TEXTURE_2D);
	{
		glTranslated(mouse_x,ScreenYSize-mouse_y,0.0f);			// Move To The Current Mouse Position
		glBegin(GL_LINES);									// Start Drawing Our Player Using Lines
			glColor3f(1,1,0);
			glVertex3f(-18,0,0);
			glVertex3f(+18,0,0);
			glVertex3f(0,-18,0);
			glVertex3f(0,+18,0);
		glEnd();
	};
	DoneText();

//	TestMessage();
}

void DrawObject(float si,GLuint texid)				// 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
		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 DrawSkelEdges(tObjekt *Obj)
{
	long I,K,M;
	float OSize;
	float ODiv=128;
	float SDiv;

	glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix
	glLoadIdentity ();													// Reset The Modelview Matrix


	gluLookAt(0,0,0,PRot.X,PRot.Y,PRot.Z,sin(Roll),cos(Roll),0);
	glTranslatef(PPos.X,PPos.Y,PPos.Z);						// Move Left 1.5 Units And Into The Screen 6.0


	SDiv=1;
	if(ShowSplines) SDiv=1;
	for(M=0;M<SkelNodes;M++)
	{
		glLoadName(M);
		glPushMatrix();
		glColor3f(0,1,1);
		OSize=PSpeed*vLength2(vSub(PPos,Node[M]->Pos))/ODiv;
		glTranslatef(Node[M]->Pos.X,Node[M]->Pos.Y,Node[M]->Pos.Z);
		if(SelV==M) { DrawObject(OSize,0); } else 
		if(LastActive==M) { DrawObject(OSize,0); } else 
		if(BasePoint==M) { DrawObject(OSize*2,2); } else 
		{DrawObject(OSize/2,1);};
		glPopMatrix();

	}
if(!ShowTexture)
{
	if(ShowSplines)
	{
	}
}															

//*/
}

void DrawEdges()
{
	long I,K,M;

	glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix
	glLoadIdentity ();													// Reset The Modelview Matrix


	gluLookAt(0,0,0,PRot.X,PRot.Y,PRot.Z,sin(Roll),cos(Roll),0);
	glTranslatef(PPos.X,PPos.Y,PPos.Z);						// Move Left 1.5 Units And Into The Screen 6.0

	for(M=0;M<Points;M++) 
	{
		if(SkelTag[M])
		{
			glLoadName(M);
			glPushMatrix();
			glColor3f(0,1,1);
			glTranslatef((Point+M)->X,(Point+M)->Y,(Point+M)->Z);
			if(SelV==M) { DrawObject(0.3,0); } else 
			if(LastActive==M) { DrawObject(0.3,0); } else 
			if(BasePoint==M) { DrawObject(0.5,2); } else 
			{DrawObject(0.15,1);};
			glPopMatrix();
		}
	}
//*/
}

void SetRollSkelMesh(tSkeletonNode *Temp,tOMatrix NewMatrix)
{
	if(Temp==NULL) return;

	SetRollMesh(Temp->MeshList,NewMatrix,Temp->Pos);
}

void SetDaRoll(tSkeletonNode *Temp,tOMatrix NewMatrix)
{
	tP3D NPos;
	NPos=vSub(Temp->Pos,Temp->Father->Pos);
	Temp->OrgPos=CalcRelPosition(NPos,&NewMatrix);
	if(Temp->Next!=NULL)
		SetDaRoll(Temp->Next,NewMatrix);
}

void SetSkelNodeRoll(tSkeletonNode *Temp,float NewRoll,tObjekt *Obj)
{
	tOMatrix NewMatrix;
	NewMatrix=CalcNewMatrix(Temp->Father->Pos,Temp->Pos,&Temp->Father->Matrix,NewRoll);
	if(Temp->Child!=NULL)
		SetDaRoll(Temp->Child,NewMatrix);
	SetRollSkelMesh(Temp,NewMatrix);
	
	Temp->Roll=NewRoll;
	Temp->Matrix=NewMatrix;
	if(Temp->Child!=NULL)
		SetSkelNodeRoll(Temp->Child,Temp->Child->Roll,Obj);
	if(Temp->Next!=NULL)
		SetSkelNodeRoll(Temp->Next,Temp->Next->Roll,Obj);
}


void PickPoints()
{
	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
					1.0f, 100.0f);		


	glGetIntegerv(GL_VIEWPORT,viewport);
	glSelectBuffer(512,buffer);
	glRenderMode(GL_SELECT);
	glInitNames();
	glPushName(0);
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	gluPickMatrix((GLdouble)mouse_x,(GLdouble) (viewport[3]-mouse_y),1.0f,1.0f,viewport);
	gluPerspective(45.0f,(GLfloat) (viewport[2]-viewport[0])/(GLfloat) (viewport[3]-viewport[1]),0.1f,100.0f);
	glMatrixMode(GL_MODELVIEW);
	if(ViewMode==0) { DrawEdges(); } else { DrawSkelEdges(Obj);}
	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(Num!=-1)
{
	if(mouse_klick==1)
	{
		if(SelV>=100)
		{
//			SetVerticeRelPoint(Obj,SelV-100,Node[LastActive]);
//			NPos=vSub(Temp->Pos,Node[Best]->Pos);
//			Temp->Rel=Node[Best];
//			Temp->RelPos=CalcRelPosition(NPos,Node[Best]->Matrix);
		} else
		{
			LastActive=SelV;
		}
	}
}
}

void DrawSkelNode(tP3D Start,tSkeletonNode *Temp,float Col)
{
	tP3D P2,PP;
	
	glColor3f(Col,Col,0);
	
	P2=Temp->Pos;		

	glVertex3f(Start.X,Start.Y,Start.Z);
	glVertex3f(P2.X,P2.Y,P2.Z);


	if(Temp->Child!=NULL) DrawSkelNode(P2,Temp->Child,Col*0.75);
	if(Temp->Next!=NULL) DrawSkelNode(Start,Temp->Next,Col);
}

// Orientierungsvektoren Anzeigen
void DrawOrientMatrix(tSkeletonNode *Temp,float Col)
{
	tP3D P2,PP;
	float S;

	P2=Temp->Pos;
	S=Temp->SphereSize;
	if(S<0.1) S=0.1;
	
	glColor3f(0,0,Col);
	glVertex3f(P2.X,P2.Y,P2.Z);
	PP=vAdd(P2,vMulK(Temp->Matrix.Up,S));
	glVertex3f(PP.X,PP.Y,PP.Z);

	glColor3f(0,Col,0);
	glVertex3f(P2.X,P2.Y,P2.Z);
	PP=vAdd(P2,vMulK(Temp->Matrix.Forward,S));
	glVertex3f(PP.X,PP.Y,PP.Z);

	glColor3f(Col,0,0);
	glVertex3f(P2.X,P2.Y,P2.Z);
	PP=vAdd(P2,vMulK(Temp->Matrix.Left,S));
	glVertex3f(PP.X,PP.Y,PP.Z);
}

long CountAnims(tAnimation *Anim)
{
	tAnimationList *List;
	tAnimFrame *Frame;
	long I=0;

	List=Anim->NodeList;
	while(List!=NULL)
	{
		Frame=List->Frame0;
		while(Frame!=NULL)
		{
			I++;
			Frame=Frame->Next;
		}
		List=List->Next;
	}
	return(I);
}

void DrawSkelSplines(tObjekt *Obj,float VisCol)
{
	long I,K,M;
	tP3D Start,P1,P2,P3,Normal;
	glLoadIdentity ();													// Reset The Modelview Matrix

	gluLookAt(0,0,0,PRot.X,PRot.Y,PRot.Z,sin(Roll),cos(Roll),0);
	glTranslatef(PPos.X,PPos.Y,PPos.Z);						// Move Left 1.5 Units And Into The Screen 6.0

	I=0;
	
//	glEnable(GL_TEXTURE_2D);
//	glBindTexture(GL_TEXTURE_2D, textures[2].texID);
//	glDisable(GL_TEXTURE_2D);
	glEnable(GL_COLOR_MATERIAL);
	glEnable(GL_LIGHT0);	
	glEnable(GL_LIGHTING);
	glBegin(GL_TRIANGLES);

//	glNormal3f(-PRot.X,-PRot.Y,-PRot.Z);
/*
	I=Obj->Polys;
	glColor3f(0.5*VisCol,0.5*VisCol,1*VisCol);
	if(ShowSplines&&ShowTexture)
	{
		CalcNormalVectors(Obj);		
		
		TempP=Obj->Poly;
		while(I>0)//TempP!=NULL)
		{
			I--;
			P1=TempP->P1A->Pos;
			P2=TempP->P2A->Pos;
			P3=TempP->P3A->Pos;
			glColor3f(TempP->Color.X,TempP->Color.Y,TempP->Color.Z);

			Normal=TempP->P1A-> Normal;
			glNormal3f(Normal.X,Normal.Y,Normal.Z);
//			glTexCoord2f(0.0f, 0.0f);
			glVertex3f(P1.X,P1.Y,P1.Z);

			Normal=TempP->P2A->Normal;
			glNormal3f(Normal.X,Normal.Y,Normal.Z);
//			glTexCoord2f(1.0f, 0.0f);
			glVertex3f(P2.X,P2.Y,P2.Z);

			Normal=TempP->P3A->Normal;
			glNormal3f(Normal.X,Normal.Y,Normal.Z);
//			glTexCoord2f(0.0f, 1.0f);
			glVertex3f(P3.X,P3.Y,P3.Z);

			TempP=TempP->Next;
		}
	}
*/
	glEnd();
	glDisable(GL_LIGHT0);	
	glDisable(GL_LIGHTING);

	glDisable(GL_TEXTURE_2D);									// Enable Texture MaPPing
	glEnable(GL_LINE_SMOOTH);
	glBegin(GL_LINES);									// Start Drawing Our Player Using Lines
	Start=Obj->Skel->Pos;
	DrawSkelNode(Start,Obj->Skel,1);

	if(LastActive!=-1)
	{
		DrawOrientMatrix(Node[LastActive],1);
		if(Node[LastActive]->Father!=NULL)
			DrawOrientMatrix(Node[LastActive]->Father,0.5);
	
	}

/*
	if(ShowSplines&&(!ShowTexture))
	{
		TempL=Obj->Line;
		while(TempL!=NULL)
		{
			glColor3f(1*VisCol,1*VisCol,1*VisCol);
			if((TempL->P1->Rel==Node[LastActive])&&(TempL->P2->Rel==Node[LastActive]))
			{
				glColor3f(1*VisCol,0,1*VisCol);
			}
			
			P1=TempL->P1->Pos;		
			P2=TempL->P2->Pos;		

			glVertex3f(P1.X,P1.Y,P1.Z);
			glVertex3f(P2.X,P2.Y,P2.Z);

			TempL=TempL->Next;
		}
	}
*/
	glEnd();

}

void DrawGrund(tGrund *Grund,bool Textured,long MatNr,float Alpha)
{
	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,View;
	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);
*/
	glLoadIdentity ();													// Reset The Modelview Matrix
	gluLookAt(0,0,0,PRot.X,PRot.Y,PRot.Z,sin(Roll),cos(Roll),0);
	glTranslatef(PPos.X,PPos.Y,PPos.Z);						// Move Left 1.5 Units And Into The Screen 6.0

/*	
	View=vSub(CLook,CPos);
	Norm(&View);
*/
	TempM->Textured=false;
	if(Textured)
	{
		if(TempM->Textured)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, textures[TempM->TexNr].texID);	

			glDisable(GL_LIGHT0);	
			glEnable(GL_COLOR_MATERIAL);
			glEnable(GL_LIGHT1);	
			glEnable(GL_LIGHTING);
/*
			glEnable(GL_COLOR_MATERIAL);
			glEnable(GL_LIGHT0);	
			glEnable(GL_LIGHTING);
*/
		} else {
			glEnable(GL_COLOR_MATERIAL);
			glEnable(GL_LIGHT0);	
			glEnable(GL_LIGHTING);
		}

	}
if(TempM->Textured)
{
//	glColor3f(1,1,1);
	glColor4f(1,1,1,Alpha);
	glBegin(GL_TRIANGLES);

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

		P1=Temp->P1;
		P2=Temp->P2;
		P3=Temp->P3;
		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);
		
		Temp=Temp->Next;
	}
	glEnd();
} else {

//	glColor3f(TempM->Color.X,TempM->Color.Y,TempM->Color.Z);
	glColor4f(TempM->Color.X,TempM->Color.Y,TempM->Color.Z,Alpha);
	glBegin(GL_TRIANGLES);
	M=1;
	Temp=Grund->Poly;
	while(Temp!=NULL)
	{
		M++;
//		DisplayedPolys++;	

		P1=Temp->P1;
		P2=Temp->P2;