physics-loader.cpp

Go to the documentation of this file.

/*
 * physics-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 physics collision shapes.  See physics-loader.h.
 */

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

#include <fstream>

#include "common/wave_ex.h"
#include "datahash/datahash_util.h"
#include "datahash/datahash_text.h"
#include "hfield/heightfield.h"
#include "perf/perf.h"
#include "threadsafe/smart_mutex.h"
#include "trimesh/trimesh.h"
#include "util/file.h"
#include "util/parsing.h"
#include "util/token_stream.h"


namespace aesop {


static const char * s_name              = "Physics Meta Loader";


// TODO: use a more general approach to per-shape context?
// Not sure if that's necessary yet...
struct shape_context_t {
        smart_ptr<hfield::Heightfield>          hfield;
        smart_ptr<trimesh::Trimesh>             trimesh;
};



//
//      PhysicsMeta -- used for component data
//

class PhysicsMeta : public ComponentData {
public:
        ~PhysicsMeta(void) throw() {
                        if (m_meta.shape) {
                                shape_context_t * ctx =
                                    (shape_context_t *) m_meta.shape->getContext();
                                if (ctx) {
                                        delete ctx;
                                }
                        }
                }

        // aesop::ComponentData class interface methods ------------------------
        void dump(IN const char * txt) const throw() {
                        DPRINTF("%s: PhysicsMeta", txt);
                        m_meta.dump(txt);
                }

        // data is public
        physics_meta_t          m_meta;

private:
};



//
//      static helper methods
//

static int
checkFlag
(
IN const char * modelFlags,
IN const char * name,
IN int value
)
{
        ASSERT(modelFlags, "null");
        ASSERT(name, "null");
        ASSERT(value, "null");

        // TODO: how can the type override and *unset* flags?
        // At the moment, flags can only be cumulative...
        if (strstr(modelFlags, name))
                return value;
        return 0;
}


#define TEST_FLAG(key, flag)                    \
        flags |= checkFlag(textFlags, key , PhysicsObject::eFlag_ ##flag );


static void
updateFlagsFromData
(
IO int& flags,
IN const Datahash * data
)
{
        if (!data)
                return;

        const char * textFlags = getOptionalString(data, "flags", "");

        TEST_FLAG("ghost",      Ghost);
        TEST_FLAG("events",     Events);
        TEST_FLAG("moveable",   Moveable);
}



static smart_ptr<PhysicsMeta>
loadShape
(
IN const Datahash * physicsData,
IN const Datahash * typeData,
IN const Datahash * instData,
IN const char * parentDir
)
{
        ASSERT(physicsData, "null");
        ASSERT(typeData, "null");
        // ASSERT(instData) -- can be null!
        ASSERT(parentDir, "null");

        // get manager
        smart_ptr<nstream::Manager> mgr =
            nstream::getFilesystemManager(parentDir);
        ASSERT_THROW(mgr, "failed to create fileystem manager");

        // get ready for return value
        smart_ptr<PhysicsMeta> pm = new PhysicsMeta;
        ASSERT(pm, "out of memory");
        physics_meta_t& meta = pm->m_meta;
        meta.clear();

        // mass? start with model, and allow type to override
        // TODO: allow instance to override!
        meta.mass = 0.0;                // assume infinite by default
        const char * val = getKeyWithOverrides("mass", instData, typeData,
            physicsData, eDatahash_Optional);
        if (val) {
                meta.mass = atof(val);
        }

        // object flags 
        updateFlagsFromData(meta.objectFlags, physicsData);
        updateFlagsFromData(meta.objectFlags, typeData);
        updateFlagsFromData(meta.objectFlags, instData);

        // load shape
        const char * shape = getString(physicsData, "shape");

        // save parent directory in case it is needed...

        // determine body based on data
        // TODO: over time, this set of if-statements could become quite
        //   large as new shapes are supported.  Should be pulled out into
        //   a separate registry.
        if (!strcmp("box", shape)) {
                const char * val = getKeyWithOverrides("dimensions",
                    instData, typeData, physicsData, eDatahash_Required);
                point3d_t p;
                parsePoint3d(val, p);
                p.dump("box dimensions");

                meta.shape = createBoxShape(p);

        } else if (!strcmp("capsule", shape)) {
                // capsule!
                float height = atof(getKeyWithOverrides("height",
                    instData, typeData, physicsData, eDatahash_Required));
                float radius = atof(getKeyWithOverrides("radius",
                    instData, typeData, physicsData, eDatahash_Required));
                meta.shape = createCapsuleShape(height, radius);

        } else if (!strcmp("trimesh", shape)) {
                // triangle mesh
                const char * tfile = getKeyWithOverrides("trimesh",
                    instData, typeData, physicsData, eDatahash_Required);
                std::string path = parentDir;
                path += "/";
                path += tfile;

                DPRINTF("Creating triangle mesh physics model from path: %s",
                    path.c_str());

                smart_ptr<trimesh::Trimesh> trimesh =
                    trimesh::Trimesh::load(path.c_str());
                ASSERT(trimesh, "failed to load trimesh");
                trimesh->dump(path.c_str());

                meta.shape = createTrimeshShape(trimesh);
                ASSERT(meta.shape, "failed to create trimesh shape");

                // stash trimesh state in shape
                shape_context_t * ctx = new shape_context_t;
                ASSERT(ctx, "out of memory");
                ctx->trimesh = trimesh;
                meta.shape->setContext(ctx);

        } else if (!strcmp("hfield", shape)) {
                // it's a heightfield
                const char * hfile = getKeyWithOverrides("hfield",
                    instData, typeData, physicsData, eDatahash_Required);

                DPRINTF("Creating heightfield physics model 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 from %s", hfile);
                hfield->dump("Loading for physics shape");

                float y = hfield->getHeight(5, 0.5);
                DPRINTF("Height at x=5, z=0.5: %f", y);

                meta.shape = createHeightfieldShape(hfield);
                ASSERT(meta.shape, "failed to create heightfield shape");

                // stash the heightfield in the collision shape!
                shape_context_t * ctx = new shape_context_t;
                ASSERT(ctx, "out of memory");
                ctx->hfield = hfield;   // take ownership
                meta.shape->setContext(ctx);
        } else {
                WAVE_EX(wex);
                wex << "Unknown physics shape: " << shape;
        }

        // all done!
        ASSERT(meta.shape, "null");
        return pm;
}



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

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

        // public class methods ------------------------------------------------
        void initialize(void) throw() { }
        bool getPhysicsMetaTS(IN smart_ptr<Instance>& instance,
                                OUT physics_meta_t& meta);

        // aesop::TypeComponentLoader class interface methods -----------------
        const char * getComponentName(void) const throw() { return "physics"; }
        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);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, smart_ptr<Datahash> > data_map_t;

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

        // private member data -------------------------------------------------
        smart_mutex             m_mutex;
        data_map_t              m_dataMap;
};

static smart_ptr<PhysicsRegistry> s_registry;



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

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

        const char * physicsId = getString(data, "id");

        // has to end in .physics
        if (strcmp("physics", GetExtension(physicsId))) {
                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 ("physicsFormat" != token)
                return false;

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

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



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

        DPRINTF("PHYSICS MODEL LOAD");
        const char * physicsId = getString(typeData, "id");
        DPRINTF("Asked to load physics component data for type: %s",
            instance->getTypeId());
        DPRINTF("  Uses physics model: %s", physicsId);

        // load or retrieve the data from disk
        smart_ptr<Datahash> physicsData;
        {
                // touching our map -- lock this part!
                mlock l(m_mutex);
                data_map_t::iterator i = m_dataMap.find(path);
                if (m_dataMap.end() != i) {
                        DPRINTF("  Already loaded physics data from disk!");
                        physicsData = i->second;
                }
        }

        if (!physicsData) {
                DPRINTF("Loading physics meta '%s' from file '%s'",
                    physicsId, path);
                physicsData = readHashFromTextFile(path);

                // touching map again: lock!
                {
                        mlock l(m_mutex);
                        m_dataMap[path] = physicsData;  // cache this!
                }
        }
        ASSERT(physicsData, "null");

        // get parent directory in case loader needs it...
        std::string parentDir;
        GetParentDirectory(path, parentDir);

        // get the physics instance data (if any) from the Instance
        smart_ptr<Datahash> instData = instance->getInstanceData("physics");
        // ASSERT(instData) -- can be null!     

        // okay, create component data
        smart_ptr<PhysicsMeta> pm;
        try {
                pm = loadShape(physicsData, typeData, instData,
                    parentDir.c_str());
                ASSERT(pm, "null");

        } catch (std::exception& e) {
                DPRINTF("Error loading physics shape from file: %s", path);
                DPRINTF("Exception: %s", e.what());

                // TODO: remove this?  handy to find problem model files...
                ASSERT(false, "Failed to load model!");
        }
        ASSERT(pm->m_meta.shape, "null");
        return pm;
}



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



//
//      public API
//

smart_ptr<TypeComponentLoader>
getPhysicsLoader
(
void
)
{
        if (!s_registry) {
                s_registry = new PhysicsRegistry;
                ASSERT(s_registry, "null");
                s_registry->initialize();
        }

        return s_registry;
}



bool
getPhysicsMetaFromInstance
(
IN smart_ptr<Instance>& instance,
OUT physics_meta_t& meta
)
{
        ASSERT(instance, "null");
        meta.clear();

        DPRINTF("getPhysicsMetaFromInstance");

        smart_ptr<ComponentData> data = instance->getComponentData("physics");
        if (!data) {
                DPRINTF("No physics data for instance?");
                return false;
        }

        smart_ptr<PhysicsMeta> pm = data;
        ASSERT(pm, "failed to upcast?");

        meta = pm->m_meta;
        return true;
}



};              // aesop namespace