particlesys.cpp

一个96K的3D游戏源码

		P3=Temp->P3;

		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);

		
		Temp=Temp->Next;
	}
	glEnd();
}

	glDisable(GL_TEXTURE_2D);
	glDisable(GL_LIGHT0);	
	glEnable(GL_LIGHT1);	
	glDisable(GL_LIGHTING);

}

void DrawMesh(tMeshList *Mesh)
{
	long I;
	if(Mesh==NULL) return;
	if(Mesh->Mesh!=NULL) 
	{
		DrawGrund(Mesh->Mesh,true,Mesh->MatNr,1);
	}
	DrawMesh(Mesh->Next);
}

void DrawSkelMesh(tSkeletonNode *Temp)
{
	if(Temp==NULL) return;

	DrawMesh(Temp->MeshList);
	DrawSkelMesh(Temp->Child);
	DrawSkelMesh(Temp->Next);
}


void DrawDaScene()
{
	long I,K,M;
	tP3D Start,P1,P2,P3,Normal;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear Screen And Depth Buffer
	glMatrixMode (GL_MODELVIEW);										// Select The Modelview Matrix

//	if(ShowGhost>0) DrawSkelSplines(Ghost,0.75);
	if(ShowGhost<2) DrawSkelSplines(Obj,1);
	if(ShowSplines) DrawSkelMesh(Obj->Skel);

	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,460,"F2-SaveModel F3-LoadModel");
	glPrint(10,460,"F2-SaveAnim  F3-LoadAnim");
	glPrint(10,440,"F4-Load BaseAnim");
	if(PlayReal)
	{ glPrint(300,90,"L - Stop PlayReal");}
	else
	{ glPrint(300,90,"L - PlayReal");};

	glPrint(360,440,"-= SPACE = PUNCH ! =-");
	if(SaveWithoutFrame0)
		glPrint(360,410,"Frame0 dropped");
/*
	glPrint(360,390,"%d",Animation);
	glPrint(360,360,"%d",BaseAni);
*/
	glPrint(400,460,"AnimPos : ");
	if(GetAnimFrame(Animation,LastActive)->StartCnt==gFrame)
	{
		glColor3f(1,1,0);
		glPrint(500,460,"<%d>",gFrame);
	} else {
		glColor3f(1,1,1);
		glPrint(400,460,"AnimPos : %d",gFrame);
	}
	glColor3f(1,1,1);


	if(Flag(Node[LastActive]->Flags,_Klopping) ) glPrint(10,190,"KLOPPING");
	if(Flag(Node[LastActive]->Flags,_Attackable) ) glPrint(10,170,"ATTACKABLE");
	glPrint(10,150,"Anims: %d",CountAnims(Animation));
	if(Flag(Node[LastActive]->Flags,_Fixed) ) glPrint(10,130,"FIXED");
	glPrint(10,110,"Klick: %d",mouse_klick);
	glPrint(10,90,"(J) AniLoop: %d",Animation->LoopPoint);
	glPrint(10,70,"(U) AniEndP: %d",Animation->EndCount);
	glPrint(10,30,"AnimCount: %d",Animation->FrameCounter);
	glPrint(10,10,"PSpeed: %f.4",PSpeed);
	if(mouse_klick==2) 
	{ glPrint(300,30,"W/S/A/D - Edit"); }
	else
	{ glPrint(300,30,"W/S/A/D - Move"); }
	glPrint(300,10,"Q/E - Roll"); 
	if(SelV!=-1) glPrint(465,90,"LM-SelectVertice");
	glPrint(465,70,"RM-EditVertice");
	glPrint(465,50,"F5-Texture On/Off");
	glPrint(465,30,"TAB-Splines On/Off");
	glPrint(465,10,"M-Ghost On/On/Off");
	glPrint(300,30,"Points: %d",Points);
	glPrint(300,70,"Lines: %d",Lines);
	glPrint(465,110,"SelV: %d",SelV);
	
/*
	glPrint(300,230,"Error: %d",ErrorVar);
	glPrint(200,210,"Matrix: %f.4,%f.4,%f.4",ErrorMatrix.Up.X,ErrorMatrix.Up.Y,ErrorMatrix.Up.Z);
	glPrint(200,190,"Matrix: %f.4,%f.4,%f.4",ErrorMatrix.Forward.X,ErrorMatrix.Forward.Y,ErrorMatrix.Forward.Z);
	glPrint(200,170,"Matrix: %f.4,%f.4,%f.4",ErrorMatrix.Left.X,ErrorMatrix.Left.Y,ErrorMatrix.Left.Z);
*/
	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 CalcPlayPos(tObjekt *Obj,tObjekt *Frame1,tObjekt *Frame2)
{
	float Mul;
	Mul=PlayPos;
	Mul/=PlayMax;
	
	Obj->Position=vAdd(Frame1->Position,vMulK(vSub(Frame2->Position,Frame1->Position),Mul));
	Obj->Rotation=vAdd(Frame1->Rotation,vMulK(vSub(Frame2->Rotation,Frame1->Rotation),Mul));

	CalcSkelPos(Obj->Skel,Frame1->Skel,Frame2->Skel,Mul);
	
	if(PlayPos<PlayMax)
	{ PlayPos+=PlaySpeed;}
	else
	{ Playing=false;}
}
*/

void CalcAllStuff(long FramesToDo)
{
	long I,K,M;
	for(I=0;I<FramesToDo;I++)
	{
		if(Playing)
		{
			gFrame=PlayPos;
			PlayPos+=PlaySpeed;
			Animation->FrameCounter+=PlaySpeed;
			if(Animation->FrameCounter>=Animation->LoopPoint) Animation->FrameCounter=0;
//			if(PlayPos>PlayLoop) PlayPos=0;
		};
		if(!PlayReal)
		{
			if(ViewMode==1)
				CalcObjUsingAnimationAndCount(Obj,Animation,gFrame);
		} else {

			CalcObjUsingAnimationAndCountReal(Obj,Animation,Animation->FrameCounter);
			SkelPhysicAusgleich(Obj->Skel);
			CalcSkelSpeeds(Obj->Skel);
			CalcSkelMovement(Obj->Skel,true);

		}
	}
}

void DrawScene()
{
	if(ViewMode==0)
	{
		PickPoints();
		DrawSplines();
		DrawEdges();
	} else {
//		if(Playing) CalcPlayPos(Obj,Frame1,Frame2);

		ReCalcSkelNode(Obj->Skel,&Kart_Matrix,&vNull,0);
		CalcSkelMesh(Obj->Skel);
		

		PickPoints();
		DrawDaScene();
		DrawSkelEdges(Obj);
	}
}


// ---- Skelettpunkt einf黦en ----
// Nr=Punkt zum einf黦en
// PreNr=Vorg鋘gerPunkt
// OPos = Position des Bezugspunktes
// OrgMatrix = BezugsOrientierungsmatrix
tSkeletonNode *AddSkelNode(long Nr,long PreNr,tP3D OPos,tOMatrix OrgMatrix,tSkeletonNode *Father_)
{
	long I,K,M;
	tP3D Up,Left,Forward;
	tP3D *P1,*P2,PPos,NPos,RPos;
	long P1N,P2N,PN;
	tOMatrix NMatrix;

	tSkeletonNode *Temp,*Child;
	Temp=(tSkeletonNode *) malloc(sizeof(tSkeletonNode));

	Node[SkelNodes]=Temp;
	SkelNodes++;

	Temp->SphereSize=1;
	Temp->Father=Father_;
	Temp->Pos=*(Point+Nr);			 // Position setzen
	if(Temp->Father!=NULL)
	{ Temp->FatherAbstand=vLength2(vSub(Temp->Pos,OPos));}
	NPos=vSub(Temp->Pos,OPos);
	Temp->OrgPos=CalcRelPosition(NPos,&OrgMatrix);
	Temp->Pos=vAdd(OPos,CalcRealPosition(Temp->OrgPos,&OrgMatrix));
	Temp->Roll=0;
//	Temp->Fixed=false;
	Temp->Flags=UnSetFlag(Temp->Flags,_Fixed);
	Temp->Matrix=CalcNewMatrix(OPos,Temp->Pos,&OrgMatrix,Temp->Roll);

	Temp->Next=NULL;
	Temp->Child=NULL;

	Child=NULL;
	for(I=0;I<Lines;I++)
	{
		P1=(Point+(Line+I)->P1);
		P2=(Point+(Line+I)->P2);
		P1N=(Line+I)->P1;
		P2N=(Line+I)->P2;
		if(((Line+I)->Tag==1) && ((P1N==Nr)|(P2N==Nr)) && ((P1N!=PreNr)&&(P2N!=PreNr)))
		{

			if(P1N==Nr) { PPos=*P2; PN=P2N; }
			if(P2N==Nr) { PPos=*P1; PN=P1N; }
			if(Child==NULL)
			{
				// Erstes Kind
				Child=AddSkelNode(PN,Nr,Temp->Pos,Temp->Matrix,Temp);
				Temp->Child=Child;
			} else {
				Child->Next=AddSkelNode(PN,Nr,Temp->Pos,Temp->Matrix,Temp);
				Child=Child->Next;
			}

		}
	}

	return(Temp);
}

/*


tObjekt *ConvertToObjekt()
{
	tObjekt *Temp;
	tOMatrix TempMatrix;
	tPoly *TempP;
	tP3D Pos;
	long I,K,M;

	Temp=(tObjekt *) malloc(sizeof(tObjekt));

	Temp->Position=vSet(0,0,0);
	Temp->Rotation=vSet(0,0,0);
	Temp->Vert=NULL;
	Temp->Vertices=0;
	Temp->Polys=0;

// Skelettpunkte berechnen
	SkelNodes=0;
	TempMatrix=KartMatrix();  // Kartesisches Koordinatensystem
	Pos=*(Point+BasePoint);
//	Temp->Skel=AddSkelNode(BasePoint,-1,Pos,Pos,TempMatrix);

	Temp->Skel=AddSkelNode(BasePoint,-1,vSet(0,0,0),KartMatrix(),NULL);


// Vertices den Skelettpunkten zuordnen
	TempL=NULL;
	for(I=0;I<Lines;I++)
	{
		if((Line+I)->Tag==0)
		{
			if(TempL==NULL)
			{
				TempL=(tLine *) malloc (sizeof(tLine));
				Temp->Line=TempL;
			} else
			{
				TempL->Next=(tLine *) malloc (sizeof(tLine));
				TempL=TempL->Next;
			}
			TempL->P1=AddPointToObj(*(Point+(Line+I)->P1),Temp);
			TempL->P2=AddPointToObj(*(Point+(Line+I)->P2),Temp);
			Temp->Lines++;
		}
	}
	
// Polys den Skelettpunkten zuordnen
	TempP=NULL;
	for(I=0;I<Polys;I++)
	{
			if(TempP==NULL)
			{
				TempP=(tPoly *) malloc (sizeof(tPoly));
				Temp->Poly=TempP;
			} else
			{
				TempP->Next=(tPoly *) malloc (sizeof(tPoly));
				TempP=TempP->Next;
			}
			TempP->P1A=AddPointToObj(*(Point+(Poly+I)->P1),Temp);
			TempP->P1=GetNrOfVerticeInObjekt(TempP->P1A,Temp);
			TempP->P2A=AddPointToObj(*(Point+(Poly+I)->P2),Temp);
			TempP->P2=GetNrOfVerticeInObjekt(TempP->P2A,Temp);
			TempP->P3A=AddPointToObj(*(Point+(Poly+I)->P3),Temp);
			TempP->P3=GetNrOfVerticeInObjekt(TempP->P3A,Temp);
			TempP->Normal=vSet(0,0,1);
			TempP->Color.X=(Poly+I)->C1;
			TempP->Color.Y=(Poly+I)->C2;
			TempP->Color.Z=(Poly+I)->C3;

/*
			TempP->P1=(Poly+I)->P1;
			TempP->P2=(Poly+I)->P2;
			TempP->P3=(Poly+I)->P3;
*/
/*
			Temp->Polys++;
	}

	
//	CreateSkelList(Temp);
	Temp->SkelList=CreateSkelList(Temp->Skel,Temp);

	return(Temp);
}
*/
void RollAround(tSkeletonNode *Temp,tP3D Val)
{
	float L;
	tP3D Pos,Up,Forward,Left;

	Up.X = sin(Roll);
    Up.Y = -cos(Roll);
	Up.Z = 0;
	Forward=PRot;
	Norm(&Forward);
	Left=vCross(Up,Forward);
	Norm(&Left);
	Up=vCross(Forward,Left);
	Norm(&Up);

	Pos=Temp->Pos;
	Pos=vAdd(Pos,vMulK(Up,-Val.Z));
	Pos=vAdd(Pos,vMulK(Left,-Val.X));
	SetSkeletonNode(Temp,Pos);
	if((Temp->Father!=NULL)&&(Temp->Father->Father!=NULL))
		RollAround(Temp->Father,vMulK(Val,0.5));
}


void MoveNode(tSkeletonNode *Temp,tP3D MoveVek)
{
	tP3D ZielP,NewPos,RelPos,Pos1,Pos2,ModVek;
	
	if((Temp->Father==NULL)|(Flag(Temp->Flags,_Fixed))) return;


// (1)
// Den Node in richtung des ZielPunktes Verschieben
	Pos1=Temp->Pos;
	ZielP=vAdd(Temp->Pos,MoveVek);
	NewPos=vSub(ZielP,Temp->Father->Pos);
	Norm(&NewPos);
	NewPos=vMulK(NewPos,Temp->FatherAbstand);

// Nur den Anteil des Knickvektors modifizieren
	RelPos=CalcRelPosition(NewPos,&Temp->Father->Matrix);
	Temp->OrgPos.X=RelPos.X;
	Temp->OrgPos.Y=RelPos.Y;
	Temp->OrgPos.Z=RelPos.Z;
  //FatherAbstand beachten
	Norm(&Temp->OrgPos);
	Temp->OrgPos=vMulK(Temp->OrgPos,Temp->FatherAbstand);

	Pos2=CalcRealPosition(Temp->OrgPos,&Temp->Father->Matrix);
	Pos2=vAdd(Pos2,Temp->Father->Pos);
	Temp->Pos=Pos2;

// verschobenen Anteil aus Move-Vektor entfernen
	ModVek=vSub(Pos2,Pos1);
	MoveVek=vSub(MoveVek,ModVek);

// Vater verschieben
	if(!Flag(Temp->Father->Flags,_Fixed)) MoveNode(Temp->Father,MoveVek);
}

void MoveNodePhysicalCorrect(tSkeletonNode *Temp,tP3D Val)
{
	tP3D Pos,Up,Forward,Left,MoveVek;
	
	Up.X = sin(Roll);
    Up.Y = -cos(Roll);
	Up.Z = 0;
	Forward=PRot;
	Norm(&Forward);
	Left=vCross(Up,Forward);
	Norm(&Left);
	Up=vCross(Forward,Left);
	Norm(&Up);

	MoveVek=vMulK(Left,Val.X);
	MoveVek=vAdd(MoveVek,vMulK(Up,Val.Y));
	MoveNode(Temp,MoveVek);
}

tP3D GetPlayerVektor(tP3D Val)
{
	tP3D Pos,Up,Forward,Left,MoveVek;

	Up.X = sin(Roll);
    Up.Y = -cos(Roll);
	Up.Z = 0;
	Forward=PRot;
	Norm(&Forward);
	Left=vCross(Up,Forward);
	Norm(&Left);
	Up=vCross(Forward,Left);
	Norm(&Up);

	MoveVek=vMulK(Left,Val.X);
	MoveVek=vAdd(MoveVek,vMulK(Up,Val.Y));
	MoveVek=vAdd(MoveVek,vMulK(Forward,Val.Z));
	return(MoveVek);
}


void Knick(tSkeletonNode *Temp,tP3D Val)
{
	tP3D Up,Left,Forward,TempLeft,Pos;
	float L;

	if((Temp->Father==NULL)/*|(Temp->Father->Father==NULL)*/) return;
	
	L=vLength2(vSub(Temp->Pos,Temp->Father->Pos));
/*	
	Forward=vSub(Temp->Pos,Temp->Father->Father->Pos);
	Norm(&Forward);
	TempLeft=vSub(Temp->Pos,Temp->Father->Pos);
	Norm(&TempLeft);

	Up=vCross(Forward,TempLeft);
	Norm(&Up);

	Left=vCross(Up,Forward);
	Norm(&Left);
*/
	Forward=Temp->Father->Matrix.Forward;
	Up=Temp->Father->Matrix.Left;
	Left=Temp->Father->Matrix.Up;

	Pos=Temp->Pos;
	Pos=vAdd(Pos,vMulK(Temp->Father->Matrix.Forward,-Val.X));
	Pos=vAdd(Pos,vMulK(Temp->Father->Matrix.Left,-Val.Z));

	Pos=vSub(Pos,Temp->Father->Pos);
	Norm(&Pos);
	Pos=vAdd(Temp->Father->Pos,vMulK(Pos,L));
	

	SetSkeletonNode(Temp,Pos);

	if(mouse_klick==2)
		if(Temp->Father!=NULL)
			Knick(Temp->Father,vMulK(Val,0.5));
}

void StartPlayReal(tSkeletonNode *Temp,tSkeletonNode *Frame1,tSkeletonNode *Frame2)
{
	Temp->OrgPos=Frame1->OrgPos;
	Temp->Roll=Frame1->Roll;
	Temp->Speed=vSet(0,0,0);
	Temp->RollSpeed=0;
	Temp->ZielRoll=Frame2->Roll;