simple-registry.cpp

Go to the documentation of this file.

/*
 * simple-registry.cpp
 *
 * Copyright (C) 2008-2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Simple implementation of a material registry
 */

// includes --------------------------------------------------------------------
#include "glut-model.h"         // always include our own header first!

#include <iostream>
#include <fstream>

#include "perf/perf.h"
#include "util/file.h"
#include "util/token_stream.h"


namespace glut {


////////////////////////////////////////////////////////////////////////////////
//
//      SimpleRegistry -- object that implements the glut::MaterialRegistry
//      interface.
//
////////////////////////////////////////////////////////////////////////////////

class SimpleRegistry : public glut::MaterialRegistry {
public:
        SimpleRegistry(IN const char * material_dir) {
                        ASSERT(material_dir, "null");
                        m_materialDir = material_dir;
                }
        ~SimpleRegistry(void) throw() { }

        smart_ptr<glut::material_t> getMaterial(IN const char * id) {
                        ASSERT(id, "null");

                        smart_ptr<glut::material_t> m = this->find(id);
                        if (m)
                                return m;

                        // not in map!  load
                        std::string path = m_materialDir;
                        path += "/";
                        path += id;

                        DPRINTF("Loading '%s' from path: %s", id, path.c_str());

                        m = new glut::material_t;
                        ASSERT(m, "null");

                        std::ifstream infile(path.c_str());
                        if (!infile.good()) {
                                WAVE_EX(wex);
                                wex << "Failed to open material file: " << path;
                        }
                        try {
                                expectToken(infile, "materialVersion");
                                expectToken(infile, "0.1");
                                expectToken(infile, "material");
                                glut::parseMaterial(infile, m_materialDir.c_str(), *m);
                        } catch (std::exception& e) {
                                WAVE_EX(wex);
                                wex << "Error loading material '" << id << "' ";
                                wex << "from path: " << path << "\n";
                                wex << e.what();
                        }

                        m_materials[id] = m;
                        return m;
                }

private:
        typedef std::map<std::string, smart_ptr<glut::material_t> > material_map_t;

        smart_ptr<glut::material_t> find(IN const char * id) {
                        material_map_t::iterator i = m_materials.find(id);
                        if (m_materials.end() == i)
                                return NULL;
                        return i->second;
                }

        material_map_t          m_materials;
        std::string             m_materialDir;
};



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<MaterialRegistry>
getSimpleRegistry
(
IN const char * materialDir
)
{
        ASSERT(materialDir, "null");
        static smart_ptr<SimpleRegistry> s_registry;
        if (!s_registry) {
                s_registry = new SimpleRegistry(materialDir);
                ASSERT(s_registry, "out of memory");
        }

        return s_registry;
}



};      // glut namespace