Asg 3: Read in (parse) and output a simple A|W object


Following Assignment 02, write a function inputCube() that reads in an Alias|Wavefront object, e.g., a simple cube.


  1. In the inputCube() function, read in the data for the verteces and faces as they are encountered. The program should contain two global lists:
  2. Create a face_t object that will be used to store the integer vertex indeces that index into the object's vertex list, basically a list of integers. The face_t object contains the following data objects: The interface and implementation for this object should be provided in separate header face.h and implementation face.cpp files.


  1. Write an outputCube() function that outputs the list of points, the group string, and the list of faces.
  2. When you write cout << points[i], the point should use the operator<< to output its list of coordinates.
  3. When you write cout << faces[i], the face should use the operator<< to output its list of vertex indices.


  1. Notice that the indices stored in the data file number from 1..n whereas C/C++ lists, including the std::vector, are indexed 0..n-1.
  2. One of two trickiest parts of this assignment is the file parsing. You should look over previous code for reading the point_t object and follow that pattern. This time, when looping through the input, you will have to decide what is being read in: a point_t object, a face_t object, or the std::string object. Each of these is identified by the leading character, i.e., v, f, or g, respectively. Therefore, your parsing loop should read in a single character and then switch on that character to decide what to read in, e.g., with std::istream& s,
      while( s.get(c) && !s.eof() ) {
        switch(c) {
          case 'v':
            // read in vertex_t object
          case 'g':
            // read in group string
          case 'f':
            // read in face_t object
  3. See Assignment 02 for how to print out pointers to coordinates (recall the (*the_points[i])[0] syntax).


  1. The cube-ccw.obj file used to test the above program is:
    v 1.0 1.0 1.0
    v 1.0 1.0 -1.0
    v 1.0 -1.0 1.0
    v 1.0 -1.0 -1.0
    v -1.0 1.0 1.0
    v -1.0 1.0 -1.0
    v -1.0 -1.0 1.0
    v -1.0 -1.0 -1.0
    g cube
    f 1 5 7 3
    f 2 1 3 4
    f 5 6 8 7
    f 6 2 4 8
    f 2 6 5 1
    f 8 4 3 7
  2. An object is represented by a list of vertices, basically a list of 3D points similar to what was used previously to display a plane.
  3. Each vertex is now used in a list of faces (polygons) that define the spatial boundary of the object. For a cube, there are 6 quadrilaterals.
  4. Note that, in general, you cannot assume that all objects are composed of quads; they could be composed on n-sided faces, or polygons. You cannot therefore assume that each face will have 4 indices into the vertex list. There will be at least 3 and at most n where n is unknown. For this reason we use the STL std::vector containers, which keep track of the size of the list.


  1. If you can parse the cube, then you should be able to parse any of the .obj files below.

  2. See also:

Turn in

Turn in all of your code, in one tar.gz archive of your asg##/ directory, including:
  1. A README file containing
    1. Course id--section no
    2. Name
    3. Brief solution description (e.g., program design, description of algorithm, etc., however appropriate).
    4. Lessons learned, identified interesting features of your program
    5. Any special usage instructions
  2. Makefile
  3. source code (.h headers and .cpp source)
  4. object code (do a make clean before tar)

How to hand in

See handin notes

Grading scheme