Okie Dokey...
Loading
Code:
bool MS3DModel::Load(const std::string & name)
{
std::ifstream inputFile( name.c_str(), std::ios::in | std::ios::binary);
if ( inputFile.fail())
return false; // "Couldn't open the model file."
inputFile.seekg( 0, std::ios::end );
long fileSize = inputFile.tellg();
inputFile.seekg( 0, std::ios::beg );
byte *pBuffer = new byte[fileSize];
//inputFile.read( pBuffer, fileSize );
inputFile.close();
const byte *pPtr = pBuffer;
MS3DHeader *pHeader = ( MS3DHeader* )pPtr;
pPtr += sizeof( MS3DHeader );
if ( strncmp( pHeader->m_ID, "MS3D000000", 10 ) != 0 )
return false; // "Not a valid Milkshape3D model file."
if ( pHeader->m_version < 3 || pHeader->m_version > 7 )
return false; // "Unhandled file version. Milkshape3D Version 1.3 through 1.7 is supported." :)
int nVertices = *( word* )pPtr;
NumVertices = nVertices;
Vertices = new Vertex[nVertices];
pPtr += sizeof( word );
int i;
for ( i = 0; i < nVertices; i++ )
{
MS3DVertex *pVertex = ( MS3DVertex* )pPtr;
Vertices[i].BoneID = pVertex->m_boneID;
memcpy( Vertices[i].Location, pVertex->m_vertex, sizeof( float )*3 );
pPtr += sizeof( MS3DVertex );
}
int nTriangles = *( word* )pPtr;
NumTriangles = nTriangles;
Triangles = new Triangle[nTriangles];
pPtr += sizeof( word );
for ( i = 0; i < nTriangles; i++ )
{
MS3DTriangle *pTriangle = ( MS3DTriangle* )pPtr;
int vertexIndices[3] = { pTriangle->m_vertexIndices[0], pTriangle->m_vertexIndices[1], pTriangle->m_vertexIndices[2] };
float t[3] = { 1.0f-pTriangle->m_t[0], 1.0f-pTriangle->m_t[1], 1.0f-pTriangle->m_t[2] };
memcpy( Triangles[i].VertexNormals, pTriangle->m_vertexNormals, sizeof( float )*3*3 );
memcpy( Triangles[i].Textures1, pTriangle->m_s, sizeof( float )*3 );
memcpy( Triangles[i].Textures2, t, sizeof( float )*3 );
memcpy( Triangles[i].VertexIndices, vertexIndices, sizeof( int )*3 );
pPtr += sizeof( MS3DTriangle );
}
int nGroups = *( word* )pPtr;
NumMeshes = nGroups;
Meshes = new Mesh[nGroups];
pPtr += sizeof( word );
for ( i = 0; i < nGroups; i++ )
{
pPtr += sizeof( byte ); // flags
pPtr += 32; // name
word nTriangles = *( word* )pPtr;
pPtr += sizeof( word );
int *pTriangleIndices = new int[nTriangles];
for ( int j = 0; j < nTriangles; j++ )
{
pTriangleIndices[j] = *( word* )pPtr;
pPtr += sizeof( word );
}
char materialIndex = *( char* )pPtr;
pPtr += sizeof( char );
Meshes[i].MaterialIndex = materialIndex;
Meshes[i].NumTriangles = nTriangles;
Meshes[i].TriangleIndices = pTriangleIndices;
}
int nMaterials = *( word* )pPtr;
NumMaterials = nMaterials;
Materials = new Material[nMaterials];
pPtr += sizeof( word );
for ( i = 0; i < nMaterials; i++ )
{
MS3DMaterial *pMaterial = ( MS3DMaterial* )pPtr;
memcpy( Materials[i].Ambient, pMaterial->m_ambient, sizeof( float )*4 );
memcpy( Materials[i].Diffuse, pMaterial->m_diffuse, sizeof( float )*4 );
memcpy( Materials[i].Specular, pMaterial->m_specular, sizeof( float )*4 );
memcpy( Materials[i].Emissive, pMaterial->m_emissive, sizeof( float )*4 );
Materials[i].Shininess = pMaterial->m_shininess;
Materials[i].TextureFilename = new char[strlen( pMaterial->m_texture )+1];
strcpy( Materials[i].TextureFilename, pMaterial->m_texture );
pPtr += sizeof( MS3DMaterial );
}
ReloadTextures();
delete[] pBuffer;
return true;
}
void MS3DModel::ReloadTextures()
{
for ( int i = 0; i < NumMaterials; i++ )
if ( strlen( Materials[i].TextureFilename ) > 0 )
Materials[i].Texture = LoadGLTexture( Materials[i].TextureFilename );
else
Materials[i].Texture = 0;
}
Drawing
Code:
void MS3DModel::Draw()
{
GLboolean texEnabled = glIsEnabled( GL_TEXTURE_2D );
// Draw by group
for ( int i = 0; i < NumMeshes; i++ )
{
const int materialIndex = Meshes[i].MaterialIndex;
if ( materialIndex >= 0 )
{
glMaterialfv( GL_FRONT, GL_AMBIENT, Materials[materialIndex].Ambient );
glMaterialfv( GL_FRONT, GL_DIFFUSE, Materials[materialIndex].Diffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, Materials[materialIndex].Specular );
glMaterialfv( GL_FRONT, GL_EMISSION, Materials[materialIndex].Emissive );
glMaterialf( GL_FRONT, GL_SHININESS, Materials[materialIndex].Shininess );
if ( Materials[materialIndex].Texture > 0 )
{
glBindTexture( GL_TEXTURE_2D, Materials[materialIndex].Texture );
glEnable( GL_TEXTURE_2D );
}
else
glDisable( GL_TEXTURE_2D );
}
else
{
// Material properties?
glDisable( GL_TEXTURE_2D );
}
glBegin( GL_TRIANGLES );
{
for ( int j = 0; j < Meshes[i].NumTriangles; j++ )
{
const int triangleIndex = Meshes[i].TriangleIndices[j];
const MS3DModel::Triangle * pTri = &(Triangles[triangleIndex]);
for ( int k = 0; k < 3; k++ )
{
const int index = pTri->VertexIndices[k];
glNormal3fv( pTri->VertexNormals[k] );
glTexCoord2f( pTri->Textures1[k], pTri->Textures2[k] );
glVertex3fv( Vertices[index].Location );
}
}
}
glEnd();
}
if ( texEnabled )
glEnable( GL_TEXTURE_2D );
else
glDisable( GL_TEXTURE_2D );
}
Now, I'm 100% positive that both of these functions are being called successfully!
Here is my Initialization function..
Code:
BOOL Initialize (GL_Window* window, Keys* keys)
{
g_window = window;
g_keys = keys;
// Start Of User Initialization
angle = 0.0;
RootNode->AddChild(Transformation);
Transformation->AddChild(Geometry);
// Now set up our max values for the camera
Cam.m_MaxForwardVelocity = 5.0f;
Cam.m_MaxPitchRate = 5.0f;
Cam.m_MaxHeadingRate = 5.0f;
Cam.m_PitchDegrees = 0.0f;
Cam.m_HeadingDegrees = 0.0f;
glClearColor (0.0f, 0.0f, 0.0f, 0.5f);
glClearDepth (1.0f);
glDepthFunc (GL_LEQUAL);
glEnable (GL_DEPTH_TEST);
glShadeModel (GL_SMOOTH);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
return TRUE;
}
And the Drawing in the GLDrawing loop thingy..
Code:
void DrawGLScene ()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
RootNode->Update();
Cam.SetPrespective();
CheckKeys();
CheckMouse();
}
All pretty straightforward, I'll post if anything comes up..