///////////////////////////////////////MD2.H//////////////////////////////////////////////////
#ifndef _MD2_H
#define _MD2_H
// These are the needed defines for the max values when loading .MD2 files
#define MD2_MAX_TRIANGLES 4096
#define MD2_MAX_VERTICES 2048
#define MD2_MAX_TEXCOORDS 2048
#define MD2_MAX_FRAMES 512
#define MD2_MAX_SKINS 32
#define MD2_MAX_FRAMESIZE (MD2_MAX_VERTICES * 4 + 128)
// This holds the header information that is read in at the beginning of the file
struct tMd2Header
{
int magic; // This is used to identify the file
int version; // The version number of the file (Must be 8)
int skinWidth; // The skin width in pixels
int skinHeight; // The skin height in pixels
int frameSize; // The size in bytes the frames are
int numSkins; // The number of skins associated with the model
int numVertices; // The number of vertices (constant for each frame)
int numTexCoords; // The number of texture coordinates
int numTriangles; // The number of faces (polygons)
int numGlCommands; // The number of gl commands
int numFrames; // The number of animation frames
int offsetSkins; // The offset in the file for the skin data
int offsetTexCoords; // The offset in the file for the texture data
int offsetTriangles; // The offset in the file for the face data
int offsetFrames; // The offset in the file for the frames data
int offsetGlCommands; // The offset in the file for the gl commands data
int offsetEnd; // The end of the file offset
};
//用来存储当前帧所读进来的顶点
struct tMd2AliasTriangle
{
byte vertex[3];
byte lightNormalIndex;
};
//这个存储帧的法线和顶点
struct tMd2Triangle
{
float vertex[3];
float normal[3];
};
// 这个存储索引到顶点和纹理坐标数组
struct tMd2Face
{
short vertexIndices[3];
short textureIndices[3];
};
// 此存储UV坐标
struct tMd2TexCoord
{
short u, v;
};
// This stores the animation scale, translation and name information for a frame, plus verts
struct tMd2AliasFrame
{
float scale[3];
float translate[3];
char name[16];
tMd2AliasTriangle aliasVertices[1];
};
// This stores the frames vertices after they have been transformed
struct tMd2Frame
{
char strName[16];
tMd2Triangle *pVertices;
};
// This stores a skin name
typedef char tMd2Skin[64];
// This class handles all of the loading code
class CLoadMD2
{
public:
CLoadMD2(); // This inits the data members
// This is the function that you call to load the MD2
bool ImportMD2(t3DModel *pModel, char *strFileName, char *strTexture);
private:
// This reads in the data from the MD2 file and stores it in the member variables
void ReadMD2Data();
// This converts the member variables to our pModel structure
void ConvertDataStructures(t3DModel *pModel);
// This computes the vertex normals for the object (used for lighting)
void ComputeNormals(t3DModel *pModel);
// This frees memory and closes the file
void CleanUp();
// The file pointer
FILE *m_FilePointer;
// Member variables
tMd2Header m_Header; // The header data
tMd2Skin *m_pSkins; // The skin data
tMd2TexCoord *m_pTexCoords; // The texture coordinates
tMd2Face *m_pTriangles; // Face index information
tMd2Frame *m_pFrames; // The frames of animation (vertices)
};
#endif
/////////////////////////////////////////////////////////////////////////////////
//
// * QUICK NOTES *
//
// This file holds all of the structure and class definitions needed to load
// a MD2 Quake2 file.
//
//
// Ben Humphrey (DigiBen)
// Game Programmer
// DigiBen@GameTutorials.com
// Co-Web Host of www.GameTutorials.com
//
// The Quake2 .Md2 file format is owned by ID Software. This tutorial is being used
// as a teaching tool to help understand model loading and animation. This should
// not be sold or used under any way for commercial use with out written conset
// from ID Software.
//
// Quake and Quake2 are trademarks of id Software.
// All trademarks used are properties of their respective owners.
//
//
///////////////////////////////////////MD2.CPP//////////////////////////////////////////////////
//***********************************************************************//
// //
// - "Talk to me like I'm a 3 year old!" Programming Lessons - //
// //
// $Author: DigiBen digiben@gametutorials.com //
// //
// $Program: MD2 Loader //
// //
// $Description: Demonstrates how to load a Quake2 MD2 Model //
// //
// $Date: 2/6/02 //
// //
//***********************************************************************//
#include "main.h"
#include "Md2.h"
/////////////////////////////////////////////////////////////////////////
//
// This file holds the code to load the Quake2 models from a .Md2 format.
// The .Md2 file is usually stored in a .zip file (don't let the extension
// fool you, just rename it to .zip), depending on where you get the models
// from. The CLoadMD2 class handles the loading, but we draw the model
// externally on our own in main.cpp. I created a converter function
// to convert to our already used model and object structures. This way
// eventually we can create a model library that can load any type of
// model that we support, as well as use inheritance to create a new class
// for each file format for the small things that each model format needs differently.
// Like the other loading tutorials, we calculate our own vertex normals.
// The .Md2 format is REALLY simple to load. That is why I chose it. The
// next tutorial will show how to load and animate Md2 files. Next, we
// will move from key frame animation to skeletal animation with the Quake3
// .Md3 files. This is also a wonderfuly easy format to load and use.
//
//
///////////////////////////////// CLOAD MD2 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This constructor initializes the md2 structures
/////
///////////////////////////////// CLOAD MD2 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
CLoadMD2::CLoadMD2()
{
// Here we initialize our structures to 0
memset(&m_Header, 0, sizeof(tMd2Header));
// Set the pointers to null
m_pSkins=NULL;
m_pTexCoords=NULL;
m_pTriangles=NULL;
m_pFrames=NULL;
}
///////////////////////////////// IMPORT MD2 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This is called by the client to open the .Md2 file, read it, then clean up
/////
///////////////////////////////// IMPORT MD2 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
bool CLoadMD2::ImportMD2(t3DModel *pModel, char *strFileName, char *strTexture)
{
char strMessage[255] = {0};
// Open the MD2 file in binary
m_FilePointer = fopen(strFileName, "rb");
// Make sure we have a valid file pointer (we found the file)
if(!m_FilePointer)
{
// Display an error message and don't load anything if no file was found
sprintf(strMessage, "Unable to find the file: %s!", strFileName);
MessageBox(NULL, strMessage, "Error", MB_OK);
return false;
}
// Just like most file formats, there is a header that needs to be read
// from the .Md2 format. If you look at the tMd2Header structure you will
// find all the data that will be read in. It's nice to know up front about
// the data that we will be reading. This makes it easy to just to large
// binary reads using fread, instead of counting and reading chunks.
// Read the header data and store it in our m_Header member variable
fread(&m_Header, 1, sizeof(tMd2Header), m_FilePointer);
// For some reason, .Md2 files MUST have a version of 8. I am not sure why,
// but if it doesn't there is something wrong and the header was read in
// incorrectly, or perhaps the file format is bad.
if(m_Header.version != 8)
{
// Display an error message for bad file format, then stop loading
sprintf(strMessage, "Invalid file format (Version not 8): %s!", strFileName);
MessageBox(NULL, strMessage, "Error", MB_OK);
return false;
}
// Now that we made sure the header had correct data, we want to read in the
// rest of the data. Once the data is read in, we need to convert it to our structures.
// Since we are only reading in the first frame of animation, there will only
// be ONE object in our t3DObject structure, held within our pModel variable.
ReadMD2Data();
// Here we pass in our model structure to it can store the read Quake data
// in our own model and object structure data
ConvertDataStructures(pModel);
// After we have read the whole MD2 file, we want to calculate our own vertex normals.
ComputeNormals(pModel);
// If there is a valid texture name passed in, we want to set the texture data
if(strTexture)
{
// Create a local material info structure
tMaterialInfo texture;
// Copy the name of the file into our texture file name variable
strcpy(texture.strFile, strTexture);
// Since there is only one texture for a .Md2 file, the ID is always 0
texture.texureId = 0;
// The tile or scale for the UV's is 1 to 1 (but Quake saves off a 0-256 ratio)
texture.uTile = texture.uTile = 1;
// We only have 1 material for a model
pModel->numOfMaterials = 1;
// Add the local material info to our model's material list
pModel->pMaterials.push_back(texture);
}
// Clean up after everything
CleanUp();
// Return a success
return true;
}
///////////////////////////////// READ MD2 DATA \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function reads in all of the model's data, except the animation frames
/////
///////////////////////////////// READ MD2 DATA \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void CLoadMD2::ReadMD2Data()
{
// Create a larger buffer for the frames of animation (not fully used yet)
unsigned char buffer[MD2_MAX_FRAMESIZE];
int j = 0;
// Here we allocate all of our memory from the header's information
m_pSkins = new tMd2Skin [m_Header.numSkins];
m_pTexCoords = new tMd2TexCoord [m_Header.numTexCoords];
m_pTriangles = new tMd2Face [m_Header.numTriangles];
m_pFrames = new tMd2Frame [m_Header.numFrames];
// Next, we start reading in the data by seeking to our skin names offset
fseek(m_FilePointer, m_Header.offsetSkins, SEEK_SET);
// Depending on the skin count, we read in each skin for this model
fread(m_pSkins, sizeof(tMd2Skin), m_Header.numSkins, m_FilePointer);
// Move the file pointer to the position in the file for texture coordinates
fseek(m_FilePointer, m_Header.offsetTexCoords, SEEK_SET);
// Read in all the texture coordinates in one fell swoop
fread(m_pTexCoords, sizeof(tMd2TexCoord), m_Header.numTexCoords, m_FilePointer);
// Move the file pointer to the triangles/face data offset
fseek(m_FilePointer, m_Header.offsetTriangles, SEEK_SET);
// Read in the face data for each triangle (vertex and texCoord indices)
fread(m_pTriangles, sizeof(tMd2Face), m_Header.numTriangles, m_FilePointer);
// Move the file pointer to the vertices (frames)
fseek(m_FilePointer, m_Header.offsetFrames, SEEK_SET);
// Assign our alias frame to our buffer memory
tMd2AliasFrame *pFrame = (tMd2AliasFrame *) buffer;
// Allocate the memory for the first frame of animation's vertices
m_pFrames[0].pVertices = new tMd2Triangle [m_Header.numVertices];
// Read in the first frame of animation
fread(pFrame, 1, m_Header.frameSize, m_FilePointer);
// Copy the name of the animation to our frames array
strcpy(m_pFrames[0].strName, pFrame->name);
// After we have read in the data for the model, since there is animation,
// This means that there are scale and translation values to be dealt with.
// To apply the scale and translation values, we simply multiply the scale (x, y, z)
// by the current vertex (x, y, z). Also notice that we switch the Y and Z values
// so that Y is faces up, NOT Z.
// Store off a vertex array pointer to cut down large lines of code
tMd2Triangle *pVertices = m_pFrames[0].pVertices;
// Go through all of the number of vertices and assign the scale and translations.
// Store the vertices in our current frame's vertex list array, while swapping Y and Z.
// Notice we also negate the Z axis as well to make the swap correctly.
for (j=0; j < m_Header.numVertices; j++)
{
pVertices[j].vertex[0] = pFrame->aliasVertices[j].vertex[0] * pFrame->scale[0] + pFrame->translate[0];
pVertices[j].vertex[2] = -1 * (pFrame->aliasVertices[j].vertex[1] * pFrame->scale[1] + pFrame->translate[1]);
pVertices[j].vertex[1] = pFrame->aliasVertices[j].vertex[2] * pFrame->scale[2] + pFrame->translate[2];
}
}
///////////////////////////////// CONVERT DATA STRUCTURES \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function converts the .md2 structures to our own model and object structures
/////
///////////////////////////////// CONVERT DATA STRUCTURES \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void CLoadMD2::ConvertDataStructures(t3DModel *pModel)
{
int j = 0, i = 0;
// Assign the number of objects, which is 1 since we only want 1 frame
// of animation. In the next tutorial each object will be a key frame
// to interpolate between.
pModel->numOfObjects = 1;
// Create a local object to store the first frame of animation's data
t3DObject currentFrame = {0};
// Assign the vertex, texture coord and face count to our new structure
currentFrame.numOfVerts = m_Header.numVertices;
currentFrame.numTexVertex = m_Header.numTexCoords;
currentFrame.numOfFaces = m_Header.numTriangles;
// Allocate memory for the vertices, texture coordinates and face data.
currentFrame.pVerts = new CVector3 [currentFrame.numOfVerts];
currentFrame.pTexVerts = new CVector2 [currentFrame.numTexVertex];
currentFrame.pFaces = new tFace [currentFrame.numOfFaces];
// Go through all of the vertices and assign them over to our structure
for (j=0; j < currentFrame.numOfVerts; j++)
{
currentFrame.pVerts[j].x = m_pFrames[0].pVertices[j].vertex[0];
currentFrame.pVerts[j].y = m_pFrames[0].pVertices[j].vertex[1];
currentFrame.pVerts[j].z = m_pFrames[0].pVertices[j].vertex[2];
}
// We can now free the old vertices stored in this frame of animation
delete m_pFrames[0].pVertices;
// Go through all of the uv coordinates and assign them over to our structure.
// The UV coordinates are not normal uv coordinates, they have a pixel ratio of
// 0 to 256. We want it to be a 0 to 1 ratio, so we divide the u value by the
// skin width and the v value by the skin height. This gives us our 0 to 1 ratio.
// For some reason also, the v coodinate is flipped upside down. We just subtract
// the v coordinate from 1 to remedy this problem.
for (j=0; j < currentFrame.numTexVertex; j++)
{
currentFrame.pTexVerts[j].x = m_pTexCoords[j].u / float(m_Header.skinWidth);
currentFrame.pTexVerts[j].y = 1 - m_pTexCoords[j].v / float(m_Header.skinHeight);
}
// Go through all of the face data and assign it over to OUR structure
for(j=0; j < currentFrame.numOfFaces; j++)
{
// Assign the vertex indices to our face data
currentFrame.pFaces[j].vertIndex[0] = m_pTriangles[j].vertexIndices[0];
currentFrame.pFaces[j].vertIndex[1] = m_pTriangles[j].vertexIndices[1];
currentFrame.pFaces[j].vertIndex[2] = m_pTriangles[j].vertexIndices[2];
// Assign the texture coord indices to our face data
currentFrame.pFaces[j].coordIndex[0] = m_pTriangles[j].textureIndices[0];
currentFrame.pFaces[j].coordIndex[1] = m_pTriangles[j].textureIndices[1];
currentFrame.pFaces[j].coordIndex[2] = m_pTriangles[j].textureIndices[2];
}
// Here we add the current object (or frame) to our list object list
pModel->pObject.push_back(currentFrame);
}
///////////////////////////////// CLEAN UP \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function cleans up our allocated memory and closes the file
/////
///////////////////////////////// CLEAN UP \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void CLoadMD2::CleanUp()
{
// This just just the regular cleanup or our md2 model class. We can free
// all of this data because we already have it stored in our own structures.
fclose(m_FilePointer); // Close the current file pointer
if(m_pSkins) delete [] m_pSkins; // Free the skins data
if(m_pTexCoords) delete m_pTexCoords; // Free the texture coord data
if(m_pTriangles) delete m_pTriangles; // Free the triangle face data
if(m_pFrames) delete m_pFrames; // Free the frames of animation
}
// *Note*
//
// Below are some math functions for calculating vertex normals. We want vertex normals
// because it makes the lighting look really smooth and life like. You probably already
// have these functions in the rest of your engine, so you can delete these and call
// your own. I wanted to add them so I could show how to calculate vertex normals.
////////////////////////////// Math Functions ////////////////////////////////*
// This computes the magnitude of a normal. (magnitude = sqrt(x^2 + y^2 + z^2)
#define Mag(Normal) (sqrt(Normal.x*Normal.x + Normal.y*Normal.y + Normal.z*Normal.z))
// This calculates a vector between 2 points and returns the result
CVector3 Vector(CVector3 vPoint1, CVector3 vPoint2)
{
CVector3 vVector; // The variable to hold the resultant vector
vVector.x = vPoint1.x - vPoint2.x; // Subtract point1 and point2 x's
vVector.y = vPoint1.y - vPoint2.y; // Subtract point1 and point2 y's
vVector.z = vPoint1.z - vPoint2.z; // Subtract point1 and point2 z's
return vVector; // Return the resultant vector
}
// This adds 2 vectors together and returns the result
CVector3 AddVector(CVector3 vVector1, CVector3 vVector2)
{
CVector3 vResult; // The variable to hold the resultant vector
vResult.x = vVector2.x + vVector1.x; // Add Vector1 and Vector2 x's
vResult.y = vVector2.y + vVector1.y; // Add Vector1 and Vector2 y's
vResult.z = vVector2.z + vVector1.z; // Add Vector1 and Vector2 z's
return vResult; // Return the resultant vector
}
// This divides a vector by a single number (scalar) and returns the result
CVector3 DivideVectorByScaler(CVector3 vVector1, float Scaler)
{
CVector3 vResult; // The variable to hold the resultant vector
vResult.x = vVector1.x / Scaler; // Divide Vector1's x value by the scaler
vResult.y = vVector1.y / Scaler; // Divide Vector1's y value by the scaler
vResult.z = vVector1.z / Scaler; // Divide Vector1's z value by the scaler
return vResult; // Return the resultant vector
}
// This returns the cross product between 2 vectors
CVector3 Cross(CVector3 vVector1, CVector3 vVector2)
{
CVector3 vCross; // The vector to hold the cross product
// Get the X value
vCross.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y));
// Get the Y value
vCross.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z));
// Get the Z value
vCross.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x));
return vCross; // Return the cross product
}
// This returns the normal of a vector
CVector3 Normalize(CVector3 vNormal)
{
double Magnitude; // This holds the magitude
Magnitude = Mag(vNormal); // Get the magnitude
vNormal.x /= (float)Magnitude; // Divide the vector's X by the magnitude
vNormal.y /= (float)Magnitude; // Divide the vector's Y by the magnitude
vNormal.z /= (float)Magnitude; // Divide the vector's Z by the magnitude
return vNormal; // Return the normal
}
///////////////////////////////// COMPUTER NORMALS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function computes the normals and vertex normals of the objects
/////
///////////////////////////////// COMPUTER NORMALS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void CLoadMD2::ComputeNormals(t3DModel *pModel)
{
CVector3 vVector1, vVector2, vNormal, vPoly[3];
// If there are no objects, we can skip this part
if(pModel->numOfObjects <= 0)
return;
// What are vertex normals? And how are they different from other normals?
// Well, if you find the normal to a triangle, you are finding a "Face Normal".
// If you give OpenGL a face normal for lighting, it will make your object look
// really flat and not very round. If we find the normal for each vertex, it makes
// the smooth lighting look. This also covers up blocky looking objects and they appear
// to have more polygons than they do. Basically, what you do is first
// calculate the face normals, then you take the average of all the normals around each
// vertex. It's just averaging. That way you get a better approximation for that vertex.
// Go through each of the objects to calculate their normals
for(int index = 0; index < pModel->numOfObjects; index++)
{
// Get the current object
t3DObject *pObject = &(pModel->pObject[index]);
// Here we allocate all the memory we need to calculate the normals
CVector3 *pNormals = new CVector3 [pObject->numOfFaces];
CVector3 *pTempNormals = new CVector3 [pObject->numOfFaces];
pObject->pNormals = new CVector3 [pObject->numOfVerts];
// Go though all of the faces of this object
for(int i=0; i < pObject->numOfFaces; i++)
{
// To cut down LARGE code, we extract the 3 points of this face
vPoly[0] = pObject->pVerts[pObject->pFaces[i].vertIndex[0]];
vPoly[1] = pObject->pVerts[pObject->pFaces[i].vertIndex[1]];
vPoly[2] = pObject->pVerts[pObject->pFaces[i].vertIndex[2]];
// Now let's calculate the face normals (Get 2 vectors and find the cross product of those 2)
vVector1 = Vector(vPoly[0], vPoly[2]); // Get the vector of the polygon (we just need 2 sides for the normal)
vVector2 = Vector(vPoly[2], vPoly[1]); // Get a second vector of the polygon
vNormal = Cross(vVector1, vVector2); // Return the cross product of the 2 vectors (normalize vector, but not a unit vector)
pTempNormals[i] = vNormal; // Save the un-normalized normal for the vertex normals
vNormal = Normalize(vNormal); // Normalize the cross product to give us the polygons normal
pNormals[i] = vNormal; // Assign the normal to the list of normals
}
//////////////// Now Get The Vertex Normals /////////////////
CVector3 vSum = {0.0, 0.0, 0.0};
CVector3 vZero = vSum;
int shared=0;
for (i = 0; i < pObject->numOfVerts; i++) // Go through all of the vertices
{
for (int j = 0; j < pObject->numOfFaces; j++) // Go through all of the triangles
{ // Check if the vertex is shared by another face
if (pObject->pFaces[j].vertIndex[0] == i ||
pObject->pFaces[j].vertIndex[1] == i ||
pObject->pFaces[j].vertIndex[2] == i)
{
vSum = AddVector(vSum, pTempNormals[j]);// Add the un-normalized normal of the shared face
shared++; // Increase the number of shared triangles
}
}
// Get the normal by dividing the sum by the shared. We negate the shared so it has the normals pointing out.
pObject->pNormals[i] = DivideVectorByScaler(vSum, float(-shared));
// Normalize the normal for the final vertex normal
pObject->pNormals[i] = Normalize(pObject->pNormals[i]);
vSum = vZero; // Reset the sum
shared = 0; // Reset the shared
}
// Free our memory and start over on the next object
delete [] pTempNormals;
delete [] pNormals;
}
}
/////////////////////////////////////////////////////////////////////////////////
//
// * QUICK NOTES *
//
// Pretty simple huh? This is probably the easiest 3D file format I have ever
// worked with, so good job Carmack! Once again, the next Md2 tutorial will cover
// the key frame animation that is associated with these models. Then you can
// actually say you have worked with real quake characters and know how they did
// their animation. Let's go over a brief explanation of this loader:
//
// The structures MUST be the same size and data types in order to load the
// Quake2 data. First we load the Header information. This tells us everything
// about the file and it's contents.
//
// After the header is loaded, we need to check if the ID is 8. This is a must.
// Don't ask me why it's 8, ask John Carmack! If the version ID checks out, then
// we can start loading the data.
//
// For each set of data you want to load is, we use an fseek() to move the file
// pointer to that location in the file that is given in the header.
//
// After you load the data, you can then convert the data structures to your own
// format, that way you don't have ot be stuck with theirs. I decided to make it
// like the other loaders for future purposes. We also compute our own normals.
//
// There is one thing I didn't mention that was NOT loaded in. There is an array
// of OpenGL commands that allow you to render the vertices in triangle strips and
// a triangle fan. This is the ugliest code I have ever seen to implement it, so
// I left it out :)
//
// I would like to thank Daniel E. Schoenblum <dansch@hops.cs.jhu.edu> for help
// with explaining the file format.
//
// Let me know if this helps you out!
//
//
// Ben Humphrey (DigiBen)
// Game Programmer
// DigiBen@GameTutorials.com
// Co-Web Host of www.GameTutorials.com
//
// The Quake2 .Md2 file format is owned by ID Software. This tutorial is being used
// as a teaching tool to help understand model loading and animation. This should
// not be sold or used under any way for commercial use with out written conset
// from ID Software.
//
// Quake and Quake2 are trademarks of id Software.
// All trademarks used are properties of their respective owners.
//
//
