struct Node_
{
	Node_ *Child_Nodes;//pointer to array of subnodes..
	WORD Num_Childs;//howmany of em?
	WORD Node_ID;//every vertex has an ID..every node a unique one..so 
                     //we know which vert belongs to which node..
	float Pos[3];//actual position of this node(cache)
	float xw,yw,zw;//actual rotation(cache)
}

struct Vertex_		//minimum vertex..normally you'll save along
                        //color+alpha and other stuff here
{
	float Pos[3];//guess what
	WORD Node_ID;//which nodes does this vert belong to?
}

//we need some struct for the surfs this way..I'll assume trias here..

struct Surface_
{
	WORD Verts[3];//indexs into vertex array for this tria
	DWORD TexID;
	//.. other shit
}
but we need to have the animation stored somehow ..
keyframes are rather common..and easy to use..:

struct KeyFrame_
{
	float Pos[3];//pos of the node(and all child ones)
	float xw,yw,zw;//rotation of the node(and all child ones)
	DWORD Time;//offset of this keyframe to the fisrt one 
			//...needed for interpolation...
}

struct Animation
{
	KeyFrame_ *KeyFrames;
	WORD Num_KeyFrames;
	DWORD StartTime;//all the times in KeyFrame_->Time are stored
                        //relative to 0 so we have to substract the
                        //starttime from the actual time..
	WORD Act_KeyFrame;
}

// we also need some struct providing the initial Node positions..
//and maintaining other shit..

struct Mesh_
{
	Vertex_ *Verts;
	DWORD Num_Verts;
	Surface_ *Surfs;
	DWORD Num_Surfs;
	Node_ *Nodes;
	WORD Num_Nodes;	
	float *Node_Pos;//contains the positions of the nodes
			//I stored the pos of the node with id x at
                        //(Nodes_Pos+x*3)
	Animation_ *Animations;
	WORD Num_Animations;
	WORD Act_Animation;
}

void Rec_RotateNode(Mesh_ *Mesh,Node_ *Node,float xw,float yw,float zw)
//rotates the passed Node and all of its childs
{
	for(int i=0;i<Mesh->Num_Verts;i++)
	{
		if((Verts+i)->Node_ID==Node_)
			//Rotate Vertex about
                        //(Mesh->Nodes+Node->Node_ID*3) by xw,yw,zw
			//Rotate it's normal
	}
	for(i=0;i<Node->Num_Childs;i++)
		Rec_RotateNode(Mesh,(Node->Child_Nodes+i),xw,yw,zw);
}

void Rec_TranslateNode(Mesh_ *Mesh,Node_ *Node,float *Pos)
//translate the passed Node and all of its childs
{
	for(int i=0;i<Mesh->Num_Verts;i++)
	{
		if((Verts+i)->Node_ID==Node_)
			//Add pos to 
                        //(Mesh->Nodes+Node->Node_ID*3) 
	}
	for(i=0;i<Node->Num_Childs;i++)
		Rec_TranslateNode(Mesh,(Node->Child_Nodes+i),Pos);
}

bool InterpolateAngles(DWORD WorldTime,DWORD StartTime,KeyFrame_ *KF1,
                      KeyFrame_ *KF2,float *xw,float *yw,float *zw)
//KF1 is the actual
{
	float angles[3];
	WorldTime-=StartTime;//get offset
	float steps=KF2->Time-KF1->Time;
	angles[0]=(KF2->xw-KF1->xw)/steps;
	angles[1]=(KF2->yw-KF1->yw)/steps;
	angles[2]=(KF2->zw-KF1->zw)/steps;
	//we only have some delta now..gotta add that to the KF1
	angles[0]=(WorldTime-KF1->Time)*angles[0]+KF1->xw;
	angles[1]=(WorldTime-KF1->Time)*angles[1]+KF1->yw;
	angles[2]=(WorldTime-KF1->Time)*angles[2]+KF1->zw;
	*xw=angles[0];
	*yw=angles[1];
	*zw=angles[2];
	if(WorldTime>KF2->Time)
	{
		//you could save events along with every keyframe..
		//you'd execute the event assigned to KF2(maybe play a
                //sound or such) now
		return 1;
	}
	return 0;
}

void InterpolatePosition(DWORD WorldTime,DWORD StartTime,KeyFrame_ *KF1,
                         KeyFrame_ *KF2,float *Pos)
//guess what it does..
{
	float pos[3];
	WorldTime-=StartTime;
	float steps=(KF2->Time-KF1->Time);
	pos[0]=(KF2->Pos.x-KF1->Pos[0])/steps;
	pos[1]=(KF2->Pos.y-KF1->Pos[1])/steps;
	pos[2]=(KF2->Pos.z-KF1->Pos[2])/steps;
	pos[0]=(WorldTime-KF1->Time)*pos[0]+KF1->Pos[0];
	pos[1]=(WorldTime-KF1->Time)*pos[1]+KF1->Pos[1];
	pos[2]=(WorldTime-KF1->Time)*pos[2]+KF1->Pos[2];
	
	Pos[0]=pos[0];
	Pos[1]=pos[1];
	Pos[2]=pos[2];
}

void Rec_Animate(Mesh_ *Mesh,Mesh_ *Cache,Node_ *Node,DWORD WorldTime)
{
	for(int i=0;i<Node->Num_Childs;i++)
		Rec_Animate(Mesh,Cache,(Node->Child_Nodes+i),WorldTime);

	if(Mesh->Num_Animations)//any anim there?
	{
		float xw,yw,zw;
		float Pos[3];
		if((Mesh->Animations+Mesh->Act_Animation-1)->Act_KeyFrame<
		(Mesh->Animations+Mesh->Act_Animation-1)->Num_Frames)
		{
			bool NextFrame=InterpolateAngles(WolrdTime,
			(Mesh->Animations+Mesh->Act_Animation-1),
                  ((Mesh->Animations+Mesh->Act_Animation-1)->
			KeyFrames+(Mesh->Animations+Mesh->Act_Animation-1)
			->Act_KeyFrame),
			((Mesh->Animations+Mesh->Act_Animation-1)->
			KeyFrames+(Mesh->Animations+Mesh->Act_Animation-1)
			->Act_KeyFrame+1),&xw,&yw,&zw);

			if(NextFrame)
			{
				(Mesh->Animations+Mesh->Act_Animation-1)
				->Act_KeyFrame++;				
			bool NextFrame=InterpolateAngles(WolrdTime,
			(Mesh->Animations+Mesh->Act_Animation-1),
                 ((Mesh->Animations+Mesh->Act_Animation-1)->
			KeyFrames+(Mesh->Animations+Mesh->Act_Animation-1)
			->Act_KeyFrame),
			((Mesh->Animations+Mesh->Act_Animation-1)->
			KeyFrames+(Mesh->Animations+Mesh->Act_Animation-1)
			->Act_KeyFrame+1),&xw,&yw,&zw);
				if(NextFrame)
				{
					//there has been a bigger breake
					//Set the anim to the last
                              //valid frame
					return;
				}
			}

			InterpolatePosition(WolrdTime,
			(Mesh->Animations+Mesh->Act_Animation-1),	
                  ((Mesh->Animations+Mesh->Act_Animation-1)->
			KeyFrames+(Mesh->Animations+Mesh->Act_Animation-1)
			->Act_KeyFrame),
			((Mesh->Animations+Mesh->Act_Animation-1)->
			KeyFrames+(Mesh->Animations+Mesh->Act_Animation-1)
			->Act_KeyFrame+1),Pos);

			Node->Pos=Pos;
			Node->xw=xw;
			Node->yw=yw;
			Node->zw=zw;
			
		}
		else //anim finished..may loop or such..
		
	}
	//translate + rotate always..we cache last anim values in the 	//node..
	Rec_RotateNode(Mesh,Node,Node->xw,Node->yw,Node->zw);
	Rec_TranslateNode(Mesh,Node,Node->Pos);
}

void RenderAnimObj(Mesh_ *Mesh,Camera_ *Camera,DWORD WorldTime)
{
	Rec_Animate(Mesh,WorldTime,Mesh->Nodes);
	//here follows the normal code for any static mesh..
	//get lighting
	//transform to viewpos
	//display
}