model-loader.cpp

Go to the documentation of this file.

/*
 * model-loader.cpp
 *
 * Copyright (C) 2008,2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Object that loads + stores glut 3D models.  See model-loader.h.
 */

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

#include <fstream>

#include "common/wave_ex.h"
#include "datahash/datahash_text.h"
#include "geometry/matrix_4.h"
#include "glut-model/glut-model.h"
#include "hfield/heightfield.h"
#include "md3-model/md3-model.h"        // Quake MD3 models
#include "obj-model/obj-model.h"        // OBJ format models
#include "opengl-effects/opengl-effects.h"
#include "perf/perf.h"
#include "skybox/skybox.h"
#include "terrain/terrain.h"
#include "threadsafe/threadsafe_map.h"
#include "util/file.h"
#include "util/parsing.h"
#include "util/token_stream.h"
#include "xform-model/xform-model.h"


namespace aesop {


static const char * s_name              = "Glut 3D Model Loader";


static const float s_radiansPerDegree   = M_PI / 180.0;


//
//      static helper methods
//


//
//      ModelData -- component data
//

class ModelData : public ComponentData {
public:
        ~ModelData(void) throw() { }

        smart_ptr<glut::Renderable>             m_model;
};



//
//      ModelRegistry - loads + retrieves 3d glut models
//

class ModelRegistry : public TypeComponentLoader,
                        public glut::MaterialRegistry {
public:
        // constructor, destructor ---------------------------------------------
        ModelRegistry(void) throw() { }
        ~ModelRegistry(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<story::Story>& story);

        // aesop::TypeComponentLoader class interface methods -----------------
        const char * getComponentName(void) const throw() { return "model"; }
        const char * getLoaderName(void) const throw() { return s_name; }
        bool isMyFormat(IN const Datahash * data,
                                IN const char * path) const;
        smart_ptr<ComponentData> loadTS(IN smart_ptr<Instance>& instance,
                                IN const Datahash * data,
                                IN const char * path);

        // glut::MaterialRegsitry class interface methods ----------------------
        smart_ptr<glut::material_t> getMaterial(IN const char * id);

private:
        // private typedefs ----------------------------------------------------

        // map from model ID --> disk file contents
        typedef threadsafe_map<std::string, smart_ptr<Datahash> > data_map_t;

        // map from material ID --> material
        typedef threadsafe_map<std::string, smart_ptr<glut::material_t> > material_map_t;

        // private helper methods ----------------------------------------------

        // private member data -------------------------------------------------
        smart_ptr<story::Story> m_story;
        data_map_t              m_modelData;
        material_map_t          m_materials;
};

static smart_ptr<ModelRegistry> s_registry;


void
ModelRegistry::initialize
(
IN smart_ptr<story::Story>& story
)
{
        ASSERT(story, "null");

        m_story = story;
}



bool
ModelRegistry::isMyFormat
(
IN const Datahash * data,
IN const char * path
)
const
{
        ASSERT(data, "null");
        ASSERT(path, "null");

        DPRINTF("Checking '%s'", path);

        // get model ID
        const char * modelId = getString(data, "id");

        // has to end in .model
        if (strcmp("model", GetExtension(modelId))) {
                DPRINTF("Extension does not match!");
                return false;
        }

        std::ifstream stream(path);
        if (!stream.good()) {
                WAVE_EX(wex);
                wex << "Failed to open file for reading: " << path;
        }

        std::string token;
        getNextToken(stream, token);
        DPRINTF("  token: %s", token.c_str());
        if ("modelFormat" != token)
                return false;

        getNextToken(stream, token);
        DPRINTF("  token: %s", token.c_str());
        if ("model-0.1" != token)
                return false;

        // okay, has the correct extension and format specification!
        return true;
}



smart_ptr<ComponentData>
ModelRegistry::loadTS
(
IN smart_ptr<Instance>& instance,
IN const Datahash * typeData,
IN const char * path
)
{
        ASSERT(instance, "null");
        ASSERT(typeData, "null");
        ASSERT(path, "null");

        const char * modelId = getString(typeData, "id");
        DPRINTF("Loading model data for model: %s", modelId);
        DPRINTF("  path: %s", path);

        std::string parentDir;
        GetParentDirectory(path, parentDir);

        // get filesystem manager
        smart_ptr<nstream::Manager> mgr =
            nstream::getFilesystemManager(parentDir.c_str());
        ASSERT(mgr, "null");

        // get the instance data (if any)
        smart_ptr<Datahash> instanceData = instance->getInstanceData("model");
        // ASSERT(instanceData) -- can be null!

        // see if we need to load the disk data again
        smart_ptr<Datahash> modelData;
        if (m_modelData.lookup(modelId, modelData) && modelData) {
                DPRINTF("  model data already loaded from disk");
        } else {
                DPRINTF("  need to load model data from disk");
                modelData = readHashFromTextFile(path);
                m_modelData.insert(modelId, modelData);
        }
        ASSERT(modelData, "null");

        smart_ptr<ModelData> md = new ModelData;
        ASSERT(md, "out of memory");

        try {
                if (strcmp("model-0.1", getString(modelData, "modelFormat"))) {
                        WAVE_EX(wex);
                        wex << "Invalid or missing model format";
                }

                const char * type =
                    getKeyWithOverrides("type", instanceData, typeData,
                        modelData, eDatahash_Required);
                DPRINTF("  model type: %s", type);

                if (!strcmp("hfield", type)) {
                        const char * hFile = getKeyWithOverrides("hfield",
                            instanceData, typeData, modelData,
                            eDatahash_Required);

                        // okay, get absolute path
//                      std::string absolute =
//                          getPathRelativeTo(path, hFile);
//                      DPRINTF("Reading heightfield from path: %s",
//                          absolute.c_str());
                        DPRINTF("Reading heightfield from path: %s",
                            hFile);
                        smart_ptr<nstream::Stream> stream =
                            nstream::openNamedStream(mgr, hFile);
                        ASSERT(stream, "null");
                        smart_ptr<hfield::Heightfield> hfield =
                            hfield::Heightfield::create(stream);
                        ASSERT(hfield, "failed to load heightfield");

                        smart_ptr<glut::Renderable> model =
                            glut::createTerrain(hfield);
                        ASSERT(model, "failed to create heightfield renderer");
                        md->m_model = model;
                } else if (!strcmp("md3", type)) {
                        DPRINTF("Loading an MD3 model!");

                        const char * md3Dir = getKeyWithOverrides("md3Dir",
                            instanceData, typeData, modelData,
                            eDatahash_Required);

                        // get absolute path to model directory
                        std::string absolute =
                            getPathRelativeTo(path, md3Dir);
                        DPRINTF("Reading md3 model from path: %s",
                            absolute.c_str());
                        md->m_model = md3::loadMd3Player(absolute.c_str());
                } else if (!strcmp("obj-model", type)) {
                        DPRINTF("Loading an OBJ model!");

                        const char * objFile = getKeyWithOverrides("file",
                            instanceData, typeData, modelData,
                            eDatahash_Required);

                        float scale = atof(getKeyWithOverrides("scale",
                            instanceData, typeData, modelData,
                            eDatahash_Required));
                        ASSERT_THROW(scale > 0,
                            "Bad obj file scale: " << scale);

                        // create a streamer::Stream
                        smart_ptr<nstream::Stream> stream =
                            nstream::openNamedStream(mgr, objFile);
                        ASSERT_THROW(stream, "Failed to open stream for file: "
                            << objFile);
                        md->m_model = obj::Model::create(stream, scale);
                } else if (!strcmp("lod-model", type)) {
                        bool isSkybox = false;
                        const char * flags = getKeyWithOverrides("flags",
                            instanceData, typeData, modelData,
                            eDatahash_Optional);
                        if (flags && !strcmp("skybox", flags)) {
                                isSkybox = true;
                        }
                        const char * filename = getKeyWithOverrides("file",
                            instanceData, typeData, modelData,
                            eDatahash_Required);
                        std::string absolute = parentDir;
                        absolute += "/";
                        absolute += filename;
                        DPRINTF("Loading glut model from path: %s",
                            absolute.c_str());
                        smart_ptr<glut::Renderable> model =
                            glut::loadModel(absolute.c_str(), this);
                        if (isSkybox) {
                                model = glut::createSkybox(model);
                        }
                        md->m_model = model;
                        ASSERT(md->m_model, "failed to load model");
                } else if (!strcmp("sphere", type)) {
                        glut::sphere_init_t si;
                        si.radius = atof(getKeyWithOverrides("radius",
                            instanceData, typeData, modelData,
                            eDatahash_Required));
                        si.nRings = atoi(getKeyWithOverrides("nRings",
                            instanceData, typeData, modelData,
                            eDatahash_Required));
                        getImgColorFromString(getKeyWithOverrides("color",
                            instanceData, typeData, modelData,
                            eDatahash_Required), si.color);
                        ASSERT_THROW(si.isValid(),
                            "Just read sphere data--not valid");

                        md->m_model = glut::createCoolSphere(si);
                        ASSERT(md->m_model, "null");

                } else if (!strcmp("xform", type)) {
                        // this model wraps another model!
                        // get base model name
                        const char * baseModel = getKeyWithOverrides("baseModel",
                            instanceData, typeData, modelData,
                            eDatahash_Required);
                        DPRINTF("xform is wrapping model: '%s'", baseModel);

                        // create fake type
                        smart_ptr<Datahash> td = Datahash::create();
                        ASSERT(td, "null");
                        td->insert("id", baseModel);

                        // get proper path
                        std::string basePath = parentDir;
                        basePath += "/";
                        basePath += baseModel;

                        // load model
                        smart_ptr<ComponentData> base =
                            this->loadTS(instance, td, basePath.c_str());
                        ASSERT(base, "null");
                        smart_ptr<ModelData> mdBase = base;
                        ASSERT_THROW(mdBase, "component data is bad type?");
                        ASSERT(mdBase->m_model, "null");

                        // get scale
                        const char * scaleSz = getKeyWithOverrides("scale",
                            instanceData, typeData, modelData,
                            eDatahash_Required);
                        float scale = atof(scaleSz);
                        DPRINTF("  scale: %s == %f", scaleSz, scale);

                        // get rotations
                        Datahash::iterator_t i;
                        modelData->getIterator("rotate", i);
                        std::string keystr;
                        hash_value_t hv;
                        matrix4_t xform;
                        xform.setXYZScale(scale);
                        while (modelData->getNextElement(i, keystr, hv)) {
                                if (hv.hash)
                                        continue;       // skip these

                                const char * val = hv.text.c_str();
                                DPRINTF("    Parsing rotation: '%s'", val);
                                if (strlen(val) < 3) {
                                        continue;       // skip this
                                }

                                char axis = val[0];
                                float degrees = atof(val + 2);
                                float radians = degrees * s_radiansPerDegree;

                                matrix4_t R;
                                switch (axis) {
                                case 'x':       R.setXRotation(radians);        break;
                                case 'y':       R.setYRotation(radians);        break;
                                case 'z':       R.setZRotation(radians);        break;
                                default:
                                        ASSERT_THROW(false,
                                            "Bad rotation axis: 'rotate "
                                            << val << "'");
                                }

                                matrix4_t T = R * xform;
                                xform = T;
                        }

                        // create wrapper object
                        md->m_model =
                            glut::createXformModel(xform, mdBase->m_model);
                        ASSERT(md->m_model, "null");

                } else {
                        WAVE_EX(wex);
                        wex << "Unknown model type: " << type;
                }
        } catch (std::exception& e) {
                DPRINTF("Error loading model '%s' from file '%s'",
                    modelId, path);
                DPRINTF("Exception: %s", e.what());

                // TODO: remove this?  handy to find problem model files...
                ASSERT(false, "Failed to load model!");
        }

        // success!
        ASSERT(md->m_model, "null");
        return md;
}



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

        // already have it?
        smart_ptr<glut::material_t> material;
        if (m_materials.lookup(id, material))
                return material;

        // don't have it!  need to load...
        material = new glut::material_t;
        ASSERT(material, "out of memory");

        std::string path = m_story->getObjectPath("model", "foo.model");
        std::string dir;
        GetParentDirectory(path.c_str(), dir);
        dir += "/wgm";

        // TODO: this path stuff is BAD BAD BAD.  Sort this out
        path = dir;
        path += "/";
        path += id;

        DPRINTF("Attempting to load material '%s' from path: %s",
            id, path.c_str());

        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");
                parseMaterial(infile, dir.c_str(), *material);
        } catch (std::exception& e) {
                WAVE_EX(wex);
                wex << "Failed to load material '" << id << "' from file: ";
                wex << path << "\n" << e.what();
        }

        // add to our (threadsafe) collection
        m_materials.insert(id, material);
        return material;
}



//
//      public API
//

smart_ptr<TypeComponentLoader>
getGlutModelLoader
(
void
)
{
        if (!s_registry) {
                WAVE_EX(wex);
                wex << "Glut model loader is not yet created";
        }

        return s_registry;
}



smart_ptr<TypeComponentLoader>
createModelLoader
(
IN smart_ptr<story::Story>& story
)
{
        ASSERT(story, "null");

        s_registry = new ModelRegistry;
        ASSERT(s_registry, "null");
        s_registry->initialize(story);

        return s_registry;
}


smart_ptr<glut::Renderable>
getModel
(
IN smart_ptr<Instance>& instance
)
{
        ASSERT(instance, "null");

        smart_ptr<ComponentData> cdata = instance->getComponentData("model");
        if (!cdata)
                return NULL;

        smart_ptr<ModelData> md = cdata;
        ASSERT(md, "failed to upcast?");

        return md->m_model;
}



};              // aesop namespace