Last modified on 20 June 2012, at 19:13

DirectX/10.0/Direct3D/Loading Maya

This tutorial will cover how to import static 3D models from Maya 2011. Note that this tutorial will be focused on Maya but it also applies to pretty much any other 3D modeling software package with some slight changes.

In the previous tutorials we have already created our own model format and rendered 3D models using that format. The goal now is to convert Maya 2011 models into our format and render them. I won't go into how to model 3D objects in Maya as there are hundreds of tutorials on the net already dedicated to that, we will instead start at the point where you have a textured and triangulated 3D model ready for export.

For the Maya export format we will use the .OBJ format as it is easily readable and good for beginners to start with.

To export your model in the .obj format you must first enable the .OBJ exporter in Maya. Click "Window", then "Settings/Preferences", then "Plug-in Manager". Scroll down to objExport.mll and select both "Loaded" and "Auto load". Now to export your model in this format click on "File", then "Export All". Now at the bottom select "Files of type:" and scroll down and select "OBJexport". Give it a file name and hit "Export All" and it will export it to a text file with a .obj extension. To look at the file you can right click and select Open With and choose WordPad to read the file. You will then see something that looks like the following:

Cube.objEdit

# This file uses centimeters as units for non-parametric coordinates.

mtllib cube.mtl
g default
v -0.500000 -0.500000 0.500000
v 0.500000 -0.500000 0.500000
v -0.500000 0.500000 0.500000
v 0.500000 0.500000 0.500000
v -0.500000 0.500000 -0.500000
v 0.500000 0.500000 -0.500000
v -0.500000 -0.500000 -0.500000
v 0.500000 -0.500000 -0.500000
vt 0.001992 0.001992
vt 0.998008 0.001992
vt 0.001992 0.998008
vt 0.998008 0.998008
vt 0.001992 0.001992
vt 0.998008 0.001992
vt 0.001992 0.998008
vt 0.998008 0.998008
vt 0.001992 0.001992
vt 0.998008 0.001992
vt 0.001992 0.998008
vt 0.998008 0.998008
vt 0.001992 0.001992
vt 0.998008 0.001992
vt 0.001992 0.998008
vt 0.998008 0.998008
vt 0.001992 0.001992
vt 0.998008 0.001992
vt 0.001992 0.998008
vt 0.998008 0.998008
vt 0.998008 0.998008
vt 0.001992 0.998008
vt 0.998008 0.001992
vt 0.001992 0.001992
vn 0.000000 0.000000 1.000000
vn 0.000000 0.000000 1.000000
vn 0.000000 0.000000 1.000000
vn 0.000000 0.000000 1.000000
vn 0.000000 1.000000 0.000000
vn 0.000000 1.000000 0.000000
vn 0.000000 1.000000 0.000000
vn 0.000000 1.000000 0.000000
vn 0.000000 0.000000 -1.000000
vn 0.000000 0.000000 -1.000000
vn 0.000000 0.000000 -1.000000
vn 0.000000 0.000000 -1.000000
vn 0.000000 -1.000000 0.000000
vn 0.000000 -1.000000 0.000000
vn 0.000000 -1.000000 0.000000
vn 0.000000 -1.000000 0.000000
vn 1.000000 0.000000 0.000000
vn 1.000000 0.000000 0.000000
vn 1.000000 0.000000 0.000000
vn 1.000000 0.000000 0.000000
vn -1.000000 0.000000 0.000000
vn -1.000000 0.000000 0.000000
vn -1.000000 0.000000 0.000000
vn -1.000000 0.000000 0.000000
s 1
g pCube1
usemtl file1SG
f 1/1/1 2/2/2 3/3/3
f 3/3/3 2/2/2 4/4/4
s 2
f 3/13/5 4/14/6 5/15/7
f 5/15/7 4/14/6 6/16/8
s 3
f 5/21/9 6/22/10 7/23/11
f 7/23/11 6/22/10 8/24/12
s 4
f 7/17/13 8/18/14 1/19/15
f 1/19/15 8/18/14 2/20/16
s 5
f 2/5/17 8/6/18 4/7/19
f 4/7/19 8/6/18 6/8/20
s 6
f 7/9/21 1/10/22 5/11/23
f 5/11/23 1/10/22 3/12/24

This particular .OBJ model file represents a 3D cube. It has 8 vertices, 24 texture coordinates and normal vectors, and 6 sides made up of 12 faces in total. When examining the file you can ignore every line unless it starts with a "V", "VT", "VN", or "F". The extra information in the file will not be needed for converting .obj to our file format. Lets look at what each of the important lines means:

1. The "V" lines are for the vertices. The cube is made up of 8 vertices for the eight corners of the cube. Each is listed in X, Y, Z float format.

2. The "VT" lines are for the texture coordinates. The cube is has 24 texture coordinates and most of them are duplicated since it records them for every vertex in every triangle in the cube model. They are listed in TU, TV float format.

3. The "VN" lines are for the normal vectors. The cube is has 24 normal vectors and most of them are duplicated again since it records them for every vertex in every triangle in the cube model. They are listed in NX, NY, NZ float format.

4. The "F" lines are for each triangle (face) in the cube model. The values listed are indexes into the vertices, texture coordinates, and normal vectors. The format of each face is:

f Vertex1/Texture1/Normal1 Vertex2/Texture2/Normal2 Vertex3/Texture3/Normal3

So a line that says "f 3/13/5 4/14/6 5/15/7" then translates to "Vertex3/Texture13/Normal5 Vertex4/Texture14/Normal6 Vertex5/Texture15/Normal7".

The order the data is listed in the .obj file is very important. For example the first vertex in the file corresponds to Vertex1 in the face list. This is the same for texture coordinates and normals as well.

Looking at the face lines in the .obj file notice that the three index groups per line make an individual triangle. And in the case of this cube model the 12 total faces make up the 6 sides of the cube that has 2 triangles per side.

Right hand to Left hand conversionEdit

By default Maya 2011 is a right handed coordinate system and exports the .obj file data in right hand coordinates. To convert that data into a left handed system which DirectX 11 is by default you have to do the following:

1. Invert the Z coordinate vertices. In the code you will see it do this: vertices[vertexIndex].z = vertices[vertexIndex].z * -1.0f;

2. Invert the TV texture coordinate. In the code you will see it do this: texcoords[texcoordIndex].y = 1.0f - texcoords[texcoordIndex].y;

3. Invert the NZ normal vertex. In the code you will see it do this: normals[normalIndex].z = normals[normalIndex].z * -1.0f;

4. Convert the drawing order from counter clockwise to clockwise. In the code I simply read in the indexes in reverse order instead of re-organizing it after the fact:

fin >> faces[faceIndex].vIndex3 >> input2 >> faces[faceIndex].tIndex3 >> input2 >> faces[faceIndex].nIndex3;
fin >> faces[faceIndex].vIndex2 >> input2 >> faces[faceIndex].tIndex2 >> input2 >> faces[faceIndex].nIndex2;
fin >> faces[faceIndex].vIndex1 >> input2 >> faces[faceIndex].tIndex1 >> input2 >> faces[faceIndex].nIndex1;

With those four steps complete the model data will be ready for DirectX 11 to render correctly.

Main.cppEdit

The program to convert the Maya 2011 .obj files into our DirectX 11 format is fairly simple and is a single program file called main.cpp. It opens a command prompt and asks for the name of the .obj file to convert. Once the user types in the name it will attempt to open the file and read in the data counts and build the structures required to read the data into. After that it reads the data into those structures and converts it to a left hand system. Once that is done it then writes the data out to a model.txt file. That file can then be renamed and used for rendering in DirectX 11 using the 3D model render project from the previous tutorial.

////////////////////////////////////////////////////////////////////////////////
// Filename: main.cpp
////////////////////////////////////////////////////////////////////////////////


//////////////
// INCLUDES //
//////////////
#include <iostream>
#include <fstream>
using namespace std;


//////////////
// TYPEDEFS //
//////////////
typedef struct
{
        float x, y, z;
}VertexType;

typedef struct
{
        int vIndex1, vIndex2, vIndex3;
        int tIndex1, tIndex2, tIndex3;
        int nIndex1, nIndex2, nIndex3;
}FaceType;


/////////////////////////
// FUNCTION PROTOTYPES //
/////////////////////////
void GetModelFilename(char*);
bool ReadFileCounts(char*, int&, int&, int&, int&);
bool LoadDataStructures(char*, int, int, int, int);


//////////////////
// MAIN PROGRAM //
//////////////////
int main()
{
        bool result;
        char filename[256];
        int vertexCount, textureCount, normalCount, faceCount;
        char garbage;


        // Read in the name of the model file.
        GetModelFilename(filename);

        // Read in the number of vertices, tex coords, normals, and faces so that the data structures can be initialized with the exact sizes needed.
        result = ReadFileCounts(filename, vertexCount, textureCount, normalCount, faceCount);
        if(!result)
        {
                return -1;
        }

        // Display the counts to the screen for information purposes.
        cout > garbage;

        return 0;
}


void GetModelFilename(char* filename)
{
        bool done;
        ifstream fin;


        // Loop until we have a file name.
        done = false;
        while(!done)
        {
                // Ask the user for the filename.
                cout > filename;

                // Attempt to open the file.
                fin.open(filename);

                if(fin.good())
                {
                        // If the file exists and there are no problems then exit since we have the file name.
                        done = true;
                }
                else
                {
                        // If the file does not exist or there was an issue opening it then notify the user and repeat the process.
                        fin.clear();
                        cout > vertices[vertexIndex].x >> vertices[vertexIndex].y >> vertices[vertexIndex].z;

                                // Invert the Z vertex to change to left hand system.
                                vertices[vertexIndex].z = vertices[vertexIndex].z * -1.0f;
                                vertexIndex++; 
                        }

                        // Read in the texture uv coordinates.
                        if(input == 't') 
                        { 
                                fin >> texcoords[texcoordIndex].x >> texcoords[texcoordIndex].y;

                                // Invert the V texture coordinates to left hand system.
                                texcoords[texcoordIndex].y = 1.0f - texcoords[texcoordIndex].y;
                                texcoordIndex++; 
                        }

                        // Read in the normals.
                        if(input == 'n') 
                        { 
                                fin >> normals[normalIndex].x >> normals[normalIndex].y >> normals[normalIndex].z;

                                // Invert the Z normal to change to left hand system.
                                normals[normalIndex].z = normals[normalIndex].z * -1.0f;
                                normalIndex++; 
                        }
                }

                // Read in the faces.
                if(input == 'f') 
                {
                        fin.get(input);
                        if(input == ' ')
                        {
                                // Read the face data in backwards to convert it to a left hand system from right hand system.
                                fin >> faces[faceIndex].vIndex3 >> input2 >> faces[faceIndex].tIndex3 >> input2 >> faces[faceIndex].nIndex3
                                    >> faces[faceIndex].vIndex2 >> input2 >> faces[faceIndex].tIndex2 >> input2 >> faces[faceIndex].nIndex2
                                    >> faces[faceIndex].vIndex1 >> input2 >> faces[faceIndex].tIndex1 >> input2 >> faces[faceIndex].nIndex1;
                                faceIndex++;
                        }
                }

                // Read in the remainder of the line.
                while(input != '\n')
                {
                        fin.get(input);
                }

                // Start reading the beginning of the next line.
                fin.get(input);
        }

        // Close the file.
        fin.close();

        // Open the output file.
        fout.open("model.txt");
        
        // Write out the file header that our model format uses.
        fout 

SummaryEdit

We can now convert Maya 2011 .obj files into our simple model format.

To Do ExercisesEdit

1. Recompile the program and run it with the supplied .obj model file.

2. Create (or have someone else make for you) a Maya 2011 model and export it in .obj format and run this program to convert it.

3. Convert this code to read in and export a different model format that you might prefer.