COLLADA, TinyXML, and OpenGL

Each element in the XML file corresponds to a TiXmlElement object in TinyXML. For example, the root element of a COLLADA file, identified by <COLLADA>, can be accessed as a TiXmlElement. This access is made possible through the RootElement function of the TiXmlDocument class.

TiXmlElement *root = doc.RootElement();

Now that we have the first element, we can call any of the functions of the TiXmlNode or TiXmlElement classes. Three of the most important functions are given as follows:

• FirstChildElement(const char* name) - Returns the TiXmlElement corresponding to the first child element with the given name
• NextSiblingElement() - Returns the TiXmlElement corresponding to the next element at the same level as this one
• Attribute(const char* name) - Returns the char array corresponding to the named attribute

The first two functions can be used together to iterate through elements in an XML file. For example, suppose the XML file has the following structure:

<parent>
   child_a>...</child_a>
   child_b>...</child_b>
   child_c>...</child_c>
</parent>

If the TiXmlElement called parent corresponds to the <parent> element, the following code will cycle through each of its children:

child = parent->FirstChildElement("child_a");
while(child != NULL) {
   ...
   child = child.NextSiblingElement();
} 

The Attribute function accepts the name of an attribute and returns the attribute's value as a char array. For example, if the element child has an attribute called name, the following code will print the attribute's value to standard output:

cout << child->Attribute("name") << endl; 

If an attribute has a numeric value, the functions QueryIntValue, QueryFloatValue, and QueryDoubleValue will return its value with the given type. For example, suppose the <child> element has an attribute called age whose value is an integer. This value can be obtained with the following code:

int age;
child->QueryIntValue("age", &age);

The TinyXML toolset provides many more classes and functions than those discussed here, and you can read through the online documentation here. But if you only want to read mesh data from a COLLADA file, the material we've discussed so far will be sufficient. The next section will show how the ColladaInterface class reads COLLADA data into an OpenGL application.

3. Rendering the Sphere with OpenGL

The ColladaInterface class provides an important function called readGeometries, which accepts a vector of ColGeom structures and the name of a COLLADA file. The function reads the mesh data in the COLLADA file and uses it to populate the vector. Specifically, the function creates one ColGeom structure for each <geometry> element in the COLLADA file. This section will present the ColGeom data structure in detail and show how it can be to render an object in 3-D.

3.1 The ColGeom Data Structure

As discussed earlier, each object in a model corresponds to a <geometry> element in a COLLADA file. To access this information in C++, colladainterface.h defines a structure called ColGeom. The definition is given as follows:

struct ColGeom {
   std::string name;         // The ID attribute of the <geometry>element
   SourceMap map;            // Contains data in the <source />elements
   GLenum primitive;         // Identifies the primitive type, such as GL_LINES
   int index_count;          // The number of indices used to draw elements
   unsigned short* indices;  // The index data from the element
};
<geometry>   SourceMap map;            // Contains data in the <source />elements
<geometry>   GLenum primitive;         // Identifies the primitive type, such as GL_LINES
</geometry><geometry>   int index_count;          // The number of indices used to draw elements
</geometry><geometry>   unsigned short* indices;  // The index data from the element
</geometry><geometry>};</geometry> 

The map field, of type SourceMap, contains the data provided by the <source> elements in the geometry. This type is defined with the following statement:

typedef std::map<std::string, SourceData> SourceMap;

The map matches the source's semantic name to its data. As explained earlier, the semantic name is given by the <vertices> element, and may take values such as POSITION, NORMALS, or TEXCOORDS. The SourceData element contains the mesh data corresponding to the <source> element, and is defined as follows:

struct SourceData {
   GLenum type;              // The data type of the mesh data, such as GL_FLOAT
   unsigned int size;        // Size of the mesh data in bytes
   unsigned int stride;      // Number of data values per group
   void* data;               // Mesh data
};

void pointers are dangerous, but there's no way to know in advance what type of data the <source> element contains. If the <source> element contains a <float_array>, the data field consists of floats. If the <source> element contains an <int_array>, data consists of ints.

3.2 Using the ColGeom Structure in OpenGL Rendering

The example code contains a file called draw_sphere.cpp. This reads from a COLLADA file called sphere.dae and places the mesh data in a vector of ColGeom structures.

ColladaInterface::readGeometries(&geom_vec, "sphere.dae"); 

After reading from sphere.dae, the application places the mesh data in OpenGL memory objects. For each ColGeom in the vector, it creates one vertex array object (VAO) and two vertex buffer objects. The first VBO contains vertex coordinates and the second contains normal vector components.

Once the VAOs and VBOs are created, the application initializes them with data from the ColGeom. For the vertex coordinates, the application accesses geom_vec.map["POSITION"] because POSITION is the semantic corresponding to vertex positions. For the normal components, the application accesses geom_vec.map["NORMAL"] because NORMAL is the semantic corresponding to normal vectors. The following code shows how this works:

for(int i=0; i<num_objects; i++) {
   glBindVertexArray(vaos[i]);
   // Set vertex coordinate data
   glBindBuffer(GL_ARRAY_BUFFER, vbos[2*i]);
   glBufferData(GL_ARRAY_BUFFER, geom_vec[i].map["POSITION"].size,
                geom_vec[i].map["POSITION"].data, GL_STATIC_DRAW);
   loc = glGetAttribLocation(program, "in_coords");
   glVertexAttribPointer(loc, geom_vec[i].map["POSITION"].stride, 
                         geom_vec[i].map["POSITION"].type, GL_FALSE, 0, 0);
   glEnableVertexAttribArray(0);
   // Set normal vector data
   glBindBuffer(GL_ARRAY_BUFFER, vbos[2*i+1]);
   glBufferData(GL_ARRAY_BUFFER, geom_vec[i].map["NORMAL"].size, 
                geom_vec[i].map["NORMAL"].data, GL_STATIC_DRAW);
   loc = glGetAttribLocation(program, "in_normals");
   glVertexAttribPointer(loc, geom_vec[i].map["NORMAL"].stride, 
                         geom_vec[i].map["NORMAL"].type, GL_FALSE, 0, 0);
   glEnableVertexAttribArray(1);
} 

The first glVertexAttribPointer call associates the vertex coordinates with the attribute in_coords. The vertex shader (draw_sphere.vert) uses this to set the location of each vertex in the model. The second call to glVertexAttribPointer associates the normal vector components with the attribute in_normals. The fragment shader uses this to determine the model's lighting. Figure 2 shows the result. 

When the window is closed, the application calls ColladaInterface::freeGeometries. This deallocates the memory associated with the mesh data read from sphere.dae. 

4.  Conclusion 

This article has presented a method for accessing data inside COLLADA files and using the data to render objects in an OpenGL application. The ColladaInterface class reads mesh data from *.dae files and places the vertex properties in ColGeom structures. This class is open-source, and there's plenty of room for improvement. But to work with the code, you need a solid understanding of TinyXML and COLLADA. 

5.  Using the code

The code archive for this article contains the source files needed to execute the application. It also contains the COLLADA file (sphere.dae) and a Makefile for the project. 

6.  History

• Submitted for editor approval: 7/24/2013.