error loading object file when "usemtl" references an undefined material

.gitignore

@@ -0,0 +1 @@
+driver

Makefile

@@ -1,10 +1,7 @@
+export SCONSFLAGS := -Q
 
-TARGET   := WFObj.o
-
-all: $(TARGET)
-
-%.o: %.cc
-	$(CXX) -c -o $@ $(CPPFLAGS) $(CXXFLAGS) $<
+all:
+	@scons
 
 clean:
-	-rm -f *~ *.o
+	@scons -c

Makefile.driver

@@ -1,18 +0,0 @@
-
-CXX      := g++
-CXXFLAGS := -O2
-SOURCE   := WFObj.cc driver.cc
-OBJS     := $(SOURCE:.cc=.o)
-LDFLAGS  := -lGL
-TARGET   := driver
-
-all: $(TARGET)
-
-$(TARGET): $(OBJS)
-	$(CXX) -o $@ $^ $(LDFLAGS)
-
-%.o: %.cc %.hh
-	$(CXX) -c -o $@ $< $(CXXFLAGS)
-
-clean:
-	-rm -f *~ *.o $(TARGET)

README

@@ -1,5 +1,5 @@
-WFObj version 1.0
+WFObj version 2.0
 Author: Josh Holtrop
 
-This utility uses OpenGL 1.x functionality to render an Alias Wavefront object
-file into a display list for repeated rendering.
+This utility uses OpenGL vertex buffer objects to render an Alias Wavefront
+object file for efficient repeated rendering.

SConstruct

@@ -0,0 +1,6 @@
+
+# vim:filetype=python
+
+env = Environment(LIBS = ['GL'], CXXFLAGS = ['-Wall', '-DGL_GLEXT_PROTOTYPES'])
+
+env.Program('driver', Glob('*.cc'))

WFObj.h

@@ -2,9 +2,12 @@
 #ifndef WFOBJ_H
 #define WFOBJ_H
 
-#include "FileLoader/FileLoader.h"
-#include "TextureLoader/TextureLoader.h"
+#ifdef GL_INCLUDE_FILE
+#include GL_INCLUDE_FILE
+#else
 #include <GL/gl.h>
+#endif
+
 #include <vector>
 #include <string>
 #include <map>
@@ -12,50 +15,66 @@
 class WFObj
 {
 public:
+    /* types */
+    class Buffer
+    {
+        public:
+            Buffer() : m_alloc(false) {data = NULL; length = 0;}
+            ~Buffer() { if (m_alloc) delete data; }
+            uint8_t *data;
+            size_t length;
+            void alloc(size_t sz)
+            {
+                length = sz;
+                data = new uint8_t[sz];
+                m_alloc = true;
+            }
+        protected:
+            bool m_alloc;
+    };
+
+    class Material
+    {
+        public:
+            enum {
+                SHININESS_BIT   = 0x01,
+                AMBIENT_BIT     = 0x02,
+                DIFFUSE_BIT     = 0x04,
+                SPECULAR_BIT    = 0x08,
+                TEXTURE_BIT     = 0x10
+            };
+            Material() : flags(0) {}
+            GLfloat shininess;
+            GLfloat ambient[4];
+            GLfloat diffuse[4];
+            GLfloat specular[4];
+            GLuint texture;
+            int flags;
+            int first_vertex;
+            int num_vertices;
+    };
+
+    typedef bool (*loadfile_t)(const char *fname, Buffer & buff);
+    typedef GLuint (*loadtexture_t)(const char *fname);
+
+    enum { VERTEX, VERTEX_TEXTURE, VERTEX_NORMAL, VERTEX_TYPES };
+
+    /* constructors */
     WFObj();
-    WFObj(FileLoader & fileLoader);
-    WFObj(TextureLoader & textureLoader);
-    WFObj(FileLoader & fileLoader, TextureLoader & textureLoader);
     ~WFObj();
 
-    class WFMtl
-    {
-    public:
-        WFMtl(WFObj * obj) { m_obj = obj; }
-        bool load(const FileLoader::Path & path);
-        void renderBegin(const std::string & mtlname,
-                bool doTextureInfo = true,
-                bool enableBlending = false);
-        void renderEnd(const std::string & mtlname,
-                bool doTextureInfo = true,
-                bool enableBlending = false);
-
-    protected:
     /* methods */
-        void clear();
-        void processInputLine(const std::string & input);
-        void pushAttributes();
-        bool load(std::istream & istr, unsigned int size);
-
-        /* variables */
-        std::map< std::string, std::vector< std::vector<std::string> > > m_data;
-        std::string m_currentMaterialName;
-        bool m_attributesPushed;
-        FileLoader::Path m_path;
-        WFObj * m_obj;
-    };
-
-    class WFFileLoader : public FileLoader
-    {
-        public:
-            virtual int getSize(const Path & path);
-            virtual Buffer load(const Path & path);
-    };
-
-    bool load(const FileLoader::Path & path);
-    GLuint render(bool doTextureInfo = true,
-            bool enableBlending = false);
+    bool load(const char *fname, loadfile_t lf = NULL, loadtexture_t lt = NULL);
+    bool load(const Buffer &buff);
     const float * const getAABB() { return m_aabb; }
+    size_t getStride() { return sizeof(GLfloat) * m_n_floats_per_vref; }
+    size_t getVertexOffset() { return 0; }
+    size_t getNormalOffset() { return 3 * sizeof(GLfloat); }
+    size_t getTextureCoordOffset() { return 6 * sizeof(GLfloat); }
+    void bindBuffers();
+    size_t getNumMaterials() { return m_num_materials; }
+    std::map<std::string, Material> & getMaterials() { return m_materials; }
+    bool doTextures() { return m_do_textures; }
 
 protected:
     /* types */
@@ -69,24 +88,51 @@ protected:
             float data[4];
     };
 
+    class VertexRef
+    {
+        public:
+            VertexRef() : vertex(0), texture(0), normal(0) {}
+            size_t vertex;
+            size_t texture;
+            size_t normal;
+            bool operator<(const VertexRef & other) const;
+    };
+
+    class Face
+    {
+        public:
+            VertexRef vertices[3];
+    };
+
     /* methods */
-    void init(FileLoader * fileLoader = NULL,
-            TextureLoader * textureLoader = NULL);
     void clear();
     void processInputLine(const std::string & input);
     Vertex readVertex(const std::vector<std::string> & parts);
-    void parseVertexIndices(const std::string & vtxref, int * ret);
-    void updateAABB(const float * const vertex);
-    bool load(std::istream & istr, unsigned int size);
+    std::vector<Face> readFaces(const std::vector<std::string> & parts);
+    VertexRef readVertexRef(const std::string ref);
+    void updateAABB();
+    static bool loadfile(const char *path, Buffer & buff);
+    std::string getLine(const Buffer & buff, size_t idx, size_t *update_idx);
+    void loadMaterial(const std::string & name);
+    bool buildVBO();
+    GLuint loadTexture(const std::string & path);
+    std::string resolvePath(const std::string & name);
 
     /* variables */
-    std::vector< std::vector<std::string> > m_data;
-    FileLoader::Path m_path;
+    std::vector<Vertex> m_vertices[VERTEX_TYPES];
+    std::map< std::string, std::vector< Face > > m_faces;
+    std::map< std::string, Material > m_materials;
     float m_aabb[6];
-    bool m_loadedVertex;
-    FileLoader * m_fileLoader;
-    TextureLoader * m_textureLoader;
-    bool m_iCreatedFileLoader;
+    std::string m_path;
+    loadfile_t m_loadfile;
+    loadtexture_t m_loadtexture;
+    std::string m_current_material_name;
+    bool m_valid;
+    GLuint m_data_vbo, m_index_vbo;
+    bool m_do_textures;
+    size_t m_n_floats_per_vref;
+    size_t m_num_materials;
+    std::map<std::string, GLuint> m_textures;
 };
 
 #endif

driver.cc

@@ -1,15 +1,9 @@
 
 #include <GL/gl.h>
 #include <iostream>
-#include "WFObj.hh"
+#include "WFObj.h"
 using namespace std;
 
-GLuint loadTexture(const char * texture)
-{
-	cout << "got texture request: '" << texture << "'" << endl;
-	return 33;
-}
-
 int main(int argc, char * argv[])
 {
 	WFObj w;
@@ -18,11 +12,10 @@ int main(int argc, char * argv[])
 		cout << "Usage: " << argv[0] << " <filename>" << endl;
 		return -2;
 	}
-	if (!w.load(argv[1], &loadTexture))
+	if (!w.load(argv[1]))
 	{
 		cout << "Couldn't open '" << argv[1] << "'!" << endl;
 		return -1;
 	}
-	w.render();
 	return 0;
 }