md2.cpp

有个小游戏

     for (j = 0; j < numFrames; j++)
     {
          frame = (frame_t*)&buffer[modelHeader->offsetFrames + frameSize * j];
          
          vertexListPtr = (vector_t*)&vertexList[numVertices * j];
          for (i = 0; i < numVertices; i++)
          {
               vertexListPtr[i].point[0] = frame->scale[0] * frame->fp[i].v[0] + frame->translate[0];
               vertexListPtr[i].point[1] = frame->scale[1] * frame->fp[i].v[1] + frame->translate[1];
               vertexListPtr[i].point[2] = frame->scale[2] * frame->fp[i].v[2] + frame->translate[2];
          }
     }
     
     numST = modelHeader->numST;
     
     st = new texCoord_t [numST];
     
     stPtr = (stIndex_t*)&buffer[modelHeader->offsetST];
     for (i = 0; i < numST; i++)
     {
          st[i].s = 0.0;
          st[i].t = 0.0;
     }
     
     numTriangles = modelHeader->numTris;
     triIndex = new mesh_t [numTriangles];
     
     // point to triangle indexes in buffer
     bufIndexPtr = (mesh_t*)&buffer[modelHeader->offsetTris];
     
     // create a mesh (triangle) list
     for (j = 0; j < numFrames; j++)         
     {
          // for all triangles in each frame
          for(i = 0; i < numTriangles; i++)
          {
               triIndex[i].meshIndex[0] = bufIndexPtr[i].meshIndex[0];
               triIndex[i].meshIndex[1] = bufIndexPtr[i].meshIndex[1];
               triIndex[i].meshIndex[2] = bufIndexPtr[i].meshIndex[2];
               triIndex[i].stIndex[0] = bufIndexPtr[i].stIndex[0];
               triIndex[i].stIndex[1] = bufIndexPtr[i].stIndex[1];
               triIndex[i].stIndex[2] = bufIndexPtr[i].stIndex[2];
          }
     }
     
     // close file and free memory
     fclose(filePtr);
	delete buffer;
     
     modelTex = NULL;
     //currentFrame = 0;
     //nextFrame = 1;
     //interpol = 0.0;
     
     return 0;
}

// CMD2Model::LoadSkin()
// access: public
// desc: loads a skin for the model
int CMD2Model::LoadSkin(char *skinFile)
{
     int i;
     
     modelTex->LoadTexture(skinFile);
     
     if (modelTex != NULL)
          SetupSkin(modelTex);
     else
          return -1;
     
     for (i = 0; i < numST; i++)
     {
          st[i].s /= (float)modelTex->width;
          st[i].t /= (float)modelTex->height;
     }
     
     return 0;
}

// CMD2Model::SetTexture()
// access: public
// desc: sets a new texture object 
int CMD2Model::SetTexture(CTexture *texture)
{
     int i;
     
     if (texture != NULL)
	{
		free(modelTex);
          modelTex = texture;
	}
     else
          return -1;
     
     SetupSkin(modelTex);
     
     for (i = 0; i < numST; i++)
     {
          st[i].s /= (float)modelTex->width;
          st[i].t /= (float)modelTex->height;
     }
     
     return 0;
}

int CMD2Model::AnimateModel(int startFrame, int endFrame, float percent,
							 int & currentFrame, int & nextFrame, float & interpol)//, CTexture * modelTex)
{
	vector_t *vList;              // current frame vertices
	vector_t *nextVList;          // next frame vertices
	int i;                                  // index counter
	float x1, y1, z1;                  // current frame point values
	float x2, y2, z2;                  // next frame point values

	vector_t vertex[3]; 

	if ((currentFrame < startFrame) || (currentFrame > endFrame))
	{
		currentFrame = (rand() % (endFrame - startFrame)) + startFrame;
	}
	nextFrame = currentFrame +1;
	if (nextFrame > endFrame)
	{
		nextFrame = startFrame;
	}

	if ((startFrame < 0) || (endFrame < 0))
		return -1;

	if ((startFrame >= numFrames) || (endFrame >= numFrames))
		return -1;

	if (interpol >= 1.0)
	{
		interpol = 0.0f;
		currentFrame++;
		if (currentFrame >= endFrame)
			currentFrame = startFrame;

		nextFrame = currentFrame + 1;

		if (nextFrame >= endFrame)
			nextFrame = startFrame;

	}

	vList = &vertexList[numVertices*currentFrame];
	nextVList = &vertexList[numVertices*nextFrame];

	glColor4f(1.0, 1.0, 1.0, 1.0);
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, modelTex->texID);
	glBegin(GL_TRIANGLES);
	for (i = 0; i < numTriangles; i++)
	{
		// get first points of each frame
		x1 = vList[triIndex[i].meshIndex[0]].point[0];
		y1 = vList[triIndex[i].meshIndex[0]].point[1];
		z1 = vList[triIndex[i].meshIndex[0]].point[2];
		x2 = nextVList[triIndex[i].meshIndex[0]].point[0];
		y2 = nextVList[triIndex[i].meshIndex[0]].point[1];
		z2 = nextVList[triIndex[i].meshIndex[0]].point[2];

		// store first interpolated vertex of triangle
		vertex[0].point[0] = x1 + interpol * (x2 - x1);
		vertex[0].point[1] = y1 + interpol * (y2 - y1);
		vertex[0].point[2] = z1 + interpol * (z2 - z1);

		// get second points of each frame
		x1 = vList[triIndex[i].meshIndex[2]].point[0];
		y1 = vList[triIndex[i].meshIndex[2]].point[1];
		z1 = vList[triIndex[i].meshIndex[2]].point[2];
		x2 = nextVList[triIndex[i].meshIndex[2]].point[0];
		y2 = nextVList[triIndex[i].meshIndex[2]].point[1];
		z2 = nextVList[triIndex[i].meshIndex[2]].point[2];

		// store second interpolated vertex of triangle
		vertex[2].point[0] = x1 + interpol * (x2 - x1);
		vertex[2].point[1] = y1 + interpol * (y2 - y1);
		vertex[2].point[2] = z1 + interpol * (z2 - z1);   

		// get third points of each frame
		x1 = vList[triIndex[i].meshIndex[1]].point[0];
		y1 = vList[triIndex[i].meshIndex[1]].point[1];
		z1 = vList[triIndex[i].meshIndex[1]].point[2];
		x2 = nextVList[triIndex[i].meshIndex[1]].point[0];
		y2 = nextVList[triIndex[i].meshIndex[1]].point[1];
		z2 = nextVList[triIndex[i].meshIndex[1]].point[2];

		// store third interpolated vertex of triangle
		vertex[1].point[0] = x1 + interpol * (x2 - x1);
		vertex[1].point[1] = y1 + interpol * (y2 - y1);
		vertex[1].point[2] = z1 + interpol * (z2 - z1);

		// calculate the normal of the triangle
		// 不启用光照，可以关闭法线计算
		//CalculateNormal(vertex[0].point, vertex[2].point, vertex[1].point);

		// render properly textured triangle
		glTexCoord2f(st[triIndex[i].stIndex[0]].s,
			st[triIndex[i].stIndex[0]].t);
		glVertex3fv(vertex[0].point);

		glTexCoord2f(st[triIndex[i].stIndex[2]].s ,
			st[triIndex[i].stIndex[2]].t);
		glVertex3fv(vertex[2].point);

		glTexCoord2f(st[triIndex[i].stIndex[1]].s,
			st[triIndex[i].stIndex[1]].t);
		glVertex3fv(vertex[1].point);
	}
	glEnd();
	glDisable(GL_TEXTURE_2D);

	interpol += percent;  // increase percentage of interpolation between frames

	return 0;
}


// RenderFrame()
// desc: renders a single key frame
int CMD2Model::RenderFrame(int keyFrame)
{
     vector_t *vList;
     int i;
     
     // create a pointer to the frame we want to show
     vList = &vertexList[numVertices * keyFrame];
     
	if (modelTex != NULL)
		// set the texture
		glBindTexture(GL_TEXTURE_2D, modelTex->texID);
     
     // display the textured model with proper lighting normals
     glBegin(GL_TRIANGLES);
     for(i = 0; i < numTriangles; i++)
     {
          CalculateNormal(vList[triIndex[i].meshIndex[0]].point,
               vList[triIndex[i].meshIndex[2]].point,
               vList[triIndex[i].meshIndex[1]].point);

		if (modelTex != NULL)
			glTexCoord2f(st[triIndex[i].stIndex[0]].s,
				st[triIndex[i].stIndex[0]].t);

          glVertex3fv(vList[triIndex[i].meshIndex[0]].point);
          
		if (modelTex != NULL)
			glTexCoord2f(st[triIndex[i].stIndex[2]].s ,
				st[triIndex[i].stIndex[2]].t);

          glVertex3fv(vList[triIndex[i].meshIndex[2]].point);
          
		if (modelTex != NULL)
			glTexCoord2f(st[triIndex[i].stIndex[1]].s,
				st[triIndex[i].stIndex[1]].t);

          glVertex3fv(vList[triIndex[i].meshIndex[1]].point);
     }
     glEnd();
     
     return 0;
}

// Unload()
// desc: unloads model data from memory
void CMD2Model::Unload()
{
     if (triIndex != NULL)
          delete [] triIndex;
     if (vertexList != NULL)
          delete [] vertexList;
     if (st != NULL)
          delete [] st; 

	if (modelTex != NULL)
		delete modelTex;
}