Jeff Molofee - NeHe's OpenGL Tutorials

}

The above code reads each of the vertex structures in the file. First memory is allocated in the model for the vertices, and then each is parsed from the file as the pointer is advanced. Several calls to memcpy will be used in this function, which copies the contents of the small arrays easily. The m_boneID member can still be ignored for now – its for skeletal animation!

int nTriangles = *( word* )pPtr;

m_numTriangles = nTriangles;

m_pTriangles = 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( m_pTriangles[i].m_vertexNormals, pTriangle->m_vertexNormals, sizeof(float)*3*3 );

memcpy( m_pTriangles[i].m_s, pTriangle->m_s, sizeof(float)*3 );

memcpy( m_pTriangles[i].m_t, t, sizeof(float)*3 );

memcpy( m_pTriangles[i].m_vertexIndices, vertexIndices, sizeof(int)*3 );

pPtr += sizeof( MS3DTriangle );

}

As for the vertices, this part of the function stores all of the triangles in the model. While most of it involves just copying the arrays from one structure to another, you'll notice the difference for the vertexIndices and t arrays. In the file, the vertex indices are stores as an array of word values, but in the model they are int values for consistency and simplicity (no nasty casting needed). So this just converts the 3 values to integers. The t values are all set to 1.0-(original value). The reason for this is that OpenGL uses a lower-left coordinate system, whereas Milkshape uses an upper-left coordinate system for its texture coordinates. This reverses the y coordinate.

int nGroups = *( word* )pPtr;

m_numMeshes = nGroups;

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

m_pMeshes[i].m_materialIndex = materialIndex;

m_pMeshes[i].m_numTriangles = nTriangles;

m_pMeshes[i].m_pTriangleIndices = pTriangleIndices;

}

The above code loads the mesh data structures (also called groups in Milkshape3D). Since the number of triangles varies from mesh to mesh, there is no standard structure to read. Instead, they are taken field by field. The memory for the triangle indices is dynamically allocated within the mesh and read one at a time.

int nMaterials = *( word* )pPtr;

m_numMaterials = nMaterials;

m_pMaterials = new Material[nMaterials];

pPtr += sizeof( word );

for (i = 0; i < nMaterials; i++) {

MS3DMaterial *pMaterial = ( MS3DMaterial* )pPtr;

memcpy( m_pMaterials[i].m_ambient, pMaterial->m_ambient, sizeof(float)*4 );

memcpy( m_pMaterials[i].m_diffuse, pMaterial->m_diffuse, sizeof(float)*4 );

memcpy( m_pMaterials[i].m_specular, pMaterial->m_specular, sizeof(float)*4 );

memcpy( m_pMaterials[i].m_emissive, pMaterial->m_emissive, sizeof(float)*4 );

m_pMaterials[i].m_shininess = pMaterial->m_shininess;

m_pMaterials[i].m_pTextureFilename = new char[strlen(pMaterial->m_texture)+1];

strcpy( m_pMaterials[i].m_pTextureFilename, pMaterial->m_texture );

pPtr += sizeof( MS3DMaterial );

}

reloadTextures();

Lastly, the material information is taken from the buffer. This is done in the same way as those above, copying each of the lighting coefficients into the new structure. Also, new memory is allocated for the texture filename, and it is copied into there. The final call to reloadTextures is used to actually load the textures and bind them to OpenGL texture objects. That function, from the Model base class, is described later.

delete[] pBuffer;

return true;

}

The last fragment frees the temporary buffer now that all the data has been copied and returns successfully.

So at this point, the protected member variables of the Model class are filled with the model information. You'll note also that this is the only code in MilkshapeModel because it is the only code specific to Milkshape3D. Now, before the model can be rendered, it is necessary to load the textures for each of its materials. This is done with the following code:

void Model::reloadTextures() {

for (int i = 0; i < m_numMaterials; i++) if (strlen(m_pMaterials[i].m_pTextureFilename) > 0) m_pMaterials[i].m_texture = LoadGLTexture(m_pMaterials[i].m_pTextureFilename);

else m_pMaterials[i].m_texture = 0;

}

For each material, the texture is loaded using a function from NeHe's base code (slightly modified from it's previous version). If the texture filename was an empty string, then it is not loaded, and instead the texture object identifier is set to 0 to indicate there is no texture.

The Code — Drawing the Model

Now we can start the code to draw the model! This is not difficult at all now that we have a careful arrangement of the data structures in memory.

void Model::draw() {

GLboolean texEnabled = glIsEnabled( GL_TEXTURE_2D );

This first part saves the state of texture mapping within OpenGL so that the function does not disturb it. Note however that it does not preserve the material properties in the same way.

Now we loop through each of the meshes and draw them individually:

// Draw By Group

for ( int i = 0; i < m_numMeshes; i++ ) {

m_pMeshes[i] will be used to reference the current mesh. Now, each mesh has its own material properties, so we set up the OpenGL states according to that. If the materialIndex of the mesh is –1 however, there is no material for this mesh and it is drawn with the OpenGL defaults.

int materialIndex = m_pMeshes[i].m_materialIndex;

if ( materialIndex >= 0 ) {

glMaterialfv( GL_FRONT, GL_AMBIENT, m_pMaterials[materialIndex].m_ambient );

glMaterialfv( GL_FRONT, GL_DIFFUSE, m_pMaterials[materialIndex].m_diffuse );

glMaterialfv( GL_FRONT, GL_SPECULAR, m_pMaterials[materialIndex].m_specular );

glMaterialfv( GL_FRONT, GL_EMISSION, m_pMaterials[materialIndex].m_emissive );

glMaterialf( GL_FRONT, GL_SHININESS, m_pMaterials[materialIndex].m_shininess );

if ( m_pMaterials[materialIndex].m_texture > 0 ) {

glBindTexture( GL_TEXTURE_2D, m_pMaterials[materialIndex].m_texture );

glEnable( GL_TEXTURE_2D );

} else glDisable( GL_TEXTURE_2D );

} else {