rename WFObj.hh to WFObj.h due to massive interface change; changed loader to use FileLoader and TextureLoader objects, accepting path via a FileLoader::Path argument instead of a raw string

git-svn-id: svn://anubis/misc/wfobj@180 bd8a9e45-a331-0410-811e-c64571078777

WFObj.cc

@@ -1,6 +1,7 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <fcntl.h>
 #include <unistd.h>
 #include <ctype.h>      // isspace()
 #include <string.h>     // strlen()
@@ -11,7 +12,7 @@
 #include <iostream>
 #include <fstream>
 #include <sstream>
-#include "WFObj.hh"
+#include "WFObj.h"
 using namespace std;
 
 #define WHITESPACE " \n\r\t\v"
@@ -68,59 +69,70 @@ static string basePath(const string & str)
     return "";
 }
 
+
 /****** WFObj functions ******/
 
+WFObj::WFObj()
+{
+    init();
+}
+
+WFObj::WFObj(FileLoader & fileLoader)
+{
+    init(&fileLoader);
+}
+
+WFObj::WFObj(TextureLoader & textureLoader)
+{
+    init(NULL, &textureLoader);
+}
+
+WFObj::WFObj(FileLoader & fileLoader, TextureLoader & textureLoader)
+{
+    init(&fileLoader, &textureLoader);
+}
+
+void WFObj::init (FileLoader * fileLoader,
+        TextureLoader * textureLoader)
+{
+    m_fileLoader = fileLoader;
+    if (m_fileLoader == NULL)
+    {
+        m_fileLoader = new WFFileLoader();
+        m_iCreatedFileLoader = true;
+    }
+    else
+    {
+        m_iCreatedFileLoader = false;
+    }
+    m_textureLoader = textureLoader;
+}
+
+WFObj::~WFObj()
+{
+    if (m_iCreatedFileLoader)
+        delete m_fileLoader;
+}
+
 void WFObj::clear()
 {
     m_data = std::vector< std::vector<std::string> >();
     m_loadedVertex = false;
 }
 
-int WFObj::filesize(const char * filename)
+bool WFObj::load(const FileLoader::Path & path)
-{
-    struct stat st;
-    if (stat(filename, &st))
-        return -1;
-    return st.st_size;
-}
-
-bool WFObj::load(const string & filename,
-                 loadTextureFunc_t loadTexture,
-                 loadFileFunc_t loadFile)
 {
     clear();
 
-    if (loadFile)
+    FileLoader::Buffer buff = m_fileLoader->load(path);
-    {
+    if (buff.size <= 0)
-        unsigned int size;
+        return false;
-        const char * filedat = (char *) loadFile(filename.c_str(), &size);
-        if (filedat && size > 0)
-        {
-            string str(filedat, size);
-            stringstream istr(str, ios_base::in);
-            load(istr, size);
-        }
-        else
-            return false;
-    }
-    else
-    {
-        int size = filesize(filename.c_str());
-        if (size < 1)
-            return false;
 
-        ifstream ifs(filename.c_str());
+    m_path = path;
-        if (!ifs.is_open())
+    string str(buff.data, buff.size);
-            return false;
+    stringstream istr(str, ios_base::in);
+    load(istr, buff.size);
 
-        load(ifs, size);
-
-        ifs.close();
-    }
-
-    m_loadTexture = loadTexture;
-    m_loadFile = loadFile;
-    m_fileName = filename;
     return true;
 }
 
@@ -177,7 +189,7 @@ GLuint WFObj::render(bool doTextureInfo)
     bool inFace = false;
     bool inMaterial = false;
     string currentMaterialName;
-    WFMtl material;
+    WFMtl material(this);
     for (int i = 0; i < len; i++)
     {
         string type = m_data[i][0];
@@ -315,9 +327,10 @@ GLuint WFObj::render(bool doTextureInfo)
         {
             if (m_data[i].size() >= 2)
             {
-                material.load(basePath(m_fileName) + m_data[i][1],
+                FileLoader::Path path(
-                              m_loadTexture,
+                        basePath(m_path.fullPath) + m_data[i][1],
-                              m_loadFile);
+                        m_data[i][1]);
+                material.load(path);
             }
         }
     }
@@ -388,61 +401,30 @@ void WFObj::parseVertexIndices(const string & vtxref, int * ret)
 
 /****** WFMtl functions ******/
 
-void WFMtl::clear()
+void WFObj::WFMtl::clear()
 {
     m_data = map< string, vector< vector<string> > >();
     m_currentMaterialName = "";
     m_attributesPushed = false;
 }
 
-int WFMtl::filesize(const char * filename)
+bool WFObj::WFMtl::load(const FileLoader::Path & path)
-{
-    struct stat st;
-    if (stat(filename, &st))
-        return -1;
-    return st.st_size;
-}
-
-bool WFMtl::load(const string & filename,
-                 WFObj::loadTextureFunc_t loadTexture,
-                 WFObj::loadFileFunc_t loadFile)
 {
     clear();
 
-    if (loadFile)
+    FileLoader::Buffer buff = m_obj->m_fileLoader->load(path);
-    {
+    if (buff.size <= 0)
-        unsigned int size;
+        return false;
-        const char * filedat = (char *) loadFile(filename.c_str(), &size);
-        if (filedat && size > 0)
-        {
-            string str(filedat, size);
-            stringstream istr(str, ios_base::in);
-            load(istr, size);
-        }
-        else
-            return false;
-    }
-    else
-    {
-        int size = filesize(filename.c_str());
-        if (size < 1)
-            return false;
 
-        ifstream ifs(filename.c_str());
+    m_path = path;
-        if (!ifs.is_open())
+    string str(buff.data, buff.size);
-            return false;
+    stringstream istr(str, ios_base::in);
+    load(istr, buff.size);
 
-        load(ifs, size);
-
-        ifs.close();
-    }
-
-    m_loadTexture = loadTexture;
-    m_fileName = filename;
     return true;
 }
 
-bool WFMtl::load(std::istream & istr, unsigned int size)
+bool WFObj::WFMtl::load(std::istream & istr, unsigned int size)
 {
     char buf[size+1];
 
@@ -468,7 +450,7 @@ bool WFMtl::load(std::istream & istr, unsigned int size)
     return true;
 }
 
-void WFMtl::processInputLine(const std::string & input)
+void WFObj::WFMtl::processInputLine(const std::string & input)
 {
     string line = input;
     vector<string> lineParts;
@@ -492,7 +474,7 @@ void WFMtl::processInputLine(const std::string & input)
     }
 }
 
-void WFMtl::renderBegin(const string & mtlname, bool doTextureInfo)
+void WFObj::WFMtl::renderBegin(const string & mtlname, bool doTextureInfo)
 {
     map< string, vector< vector<string> > >::iterator it = m_data.find(mtlname);
     if (it == m_data.end())
@@ -577,13 +559,15 @@ void WFMtl::renderBegin(const string & mtlname, bool doTextureInfo)
         {
             if (doTextureInfo)
             {
-                /* TODO: figure out how i want to load the texture */
                 if (stmts[i].size() == 2)
                 {
-                    if (m_loadTexture != NULL)
+                    if (m_obj->m_textureLoader != NULL)
                     {
-                        GLuint tex = m_loadTexture( (basePath(m_fileName) +
+                        FileLoader::Path path(
-                                                     stmts[i][1]).c_str() );
+                                basePath(m_path.fullPath + stmts[i][1]),
+                                stmts[i][1]);
+                        GLuint tex = m_obj->m_textureLoader->load(path,
+                                *m_obj->m_fileLoader);
                         if (tex > 0)
                         {
 #ifdef DEBUGGL
@@ -622,7 +606,7 @@ void WFMtl::renderBegin(const string & mtlname, bool doTextureInfo)
     }
 }
 
-void WFMtl::pushAttributes()
+void WFObj::WFMtl::pushAttributes()
 {
     if (m_attributesPushed)
         return;
@@ -633,7 +617,7 @@ void WFMtl::pushAttributes()
     glPushAttrib(GL_LIGHTING_BIT | GL_TEXTURE_BIT);
 }
 
-void WFMtl::renderEnd(const string & mtlname, bool doTextureInfo)
+void WFObj::WFMtl::renderEnd(const string & mtlname, bool doTextureInfo)
 {
     map< string, vector< vector<string> > >::iterator it = m_data.find(mtlname);
     if (it == m_data.end())
@@ -648,3 +632,34 @@ void WFMtl::renderEnd(const string & mtlname, bool doTextureInfo)
     }
 }
 
+
+/****** WFFileLoader functions ******/
+
+int WFObj::WFFileLoader::getSize(const Path & path)
+{
+    struct stat st;
+
+    if (path.fullPath == "")
+        return -1;
+    if (stat(path.fullPath.c_str(), &st))
+        return -2;
+    return st.st_size;
+}
+
+FileLoader::Buffer WFObj::WFFileLoader::load(const Path & path)
+{
+    int size = getSize(path);
+    if (size > 0)
+    {
+        int fd = open(path.fullPath.c_str(), O_RDONLY);
+        if (fd > 0)
+        {
+            Buffer buf(size);
+            int num_read = read(fd, buf.data, size);
+            close(fd);
+            if (num_read > 0)
+                return buf;
+        }
+    }
+    return Buffer(0);
+}

WFObj.h

@@ -0,0 +1,89 @@
+
+#ifndef WFOBJ_H
+#define WFOBJ_H
+
+#include "FileLoader/FileLoader.h"
+#include "TextureLoader/TextureLoader.h"
+#include <GL/gl.h>
+#include <vector>
+#include <string>
+#include <map>
+
+class WFObj
+{
+public:
+    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);
+        void renderEnd(const std::string & mtlname,
+                bool doTextureInfo = true);
+
+    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);
+    const float * const getAABB() { return m_aabb; }
+
+protected:
+    /* types */
+    class Vertex
+    {
+    public:
+        float operator[](int idx) const { return data[idx]; }
+        float & operator[](int idx) { return data[idx]; }
+        float * getData() { return data; }
+    private:
+        float data[4];
+    };
+
+    /* 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);
+
+    /* variables */
+    std::vector< std::vector<std::string> > m_data;
+    FileLoader::Path m_path;
+    float m_aabb[6];
+    bool m_loadedVertex;
+    FileLoader * m_fileLoader;
+    TextureLoader * m_textureLoader;
+    bool m_iCreatedFileLoader;
+};
+
+#endif

WFObj.hh

@@ -1,78 +0,0 @@
-
-#ifndef WFOBJ_H
-#define WFOBJ_H
-
-#include <GL/gl.h>
-#include <vector>
-#include <string>
-#include <map>
-
-class WFObj
-{
-public:
-    typedef GLuint (*loadTextureFunc_t)(const char * texture);
-    typedef void * (*loadFileFunc_t)(const char * filename,
-                                     unsigned int * length);
-    bool load(const std::string & filename,
-              loadTextureFunc_t loadTexture = NULL,
-              loadFileFunc_t loadFile = NULL);
-    GLuint render(bool doTextureInfo = true);
-    const float * const getAABB() { return m_aabb; }
-
-protected:
-    /* types */
-    class Vertex
-    {
-    public:
-        float operator[](int idx) const { return data[idx]; }
-        float & operator[](int idx) { return data[idx]; }
-        float * getData() { return data; }
-    private:
-        float data[4];
-    };
-
-    /* methods */
-    void clear();
-    int filesize(const char * filename);
-    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);
-
-    /* variables */
-    std::vector< std::vector<std::string> > m_data;
-    loadTextureFunc_t m_loadTexture;
-    loadFileFunc_t m_loadFile;
-    std::string m_fileName;
-    float m_aabb[6];
-    bool m_loadedVertex;
-};
-
-
-class WFMtl
-{
-public:
-    bool load(const std::string & filename,
-              WFObj::loadTextureFunc_t loadTexture = NULL,
-              WFObj::loadFileFunc_t loadFile = NULL);
-    void renderBegin(const std::string & mtlname, bool doTextureInfo = true);
-    void renderEnd(const std::string & mtlname, bool doTextureInfo = true);
-
-protected:
-    /* methods */
-    void clear();
-    int filesize(const char * filename);
-    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;
-    WFObj::loadTextureFunc_t m_loadTexture;
-    std::string m_fileName;
-};
-
-#endif