md3-model.cpp

Go to the documentation of this file.

/*
 * md3-model.cpp
 *
 * Copyright (C) 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.
 *
 * Entrypoint to md3-model library
 */

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

#include "animation-state/animation-state.h"
#include "perf/perf.h"
#include "Md3Player.h"


namespace md3 {



struct anim_entry_t {
        Md3PlayerAnimType       index1;
        Md3PlayerAnimType       index2;
};


// maps from animation verb --> animation information
typedef std::map<std::string, anim_entry_t> animation_map_t;



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
addAnimation
(
IN animation_map_t * map,
IN const char * verb,
IN Md3PlayerAnimType index1,
IN Md3PlayerAnimType index2
)
{
        ASSERT(map, "null");
        ASSERT(verb, "null");

        anim_entry_t ae;
        ae.index1 = index1;
        ae.index2 = index2;

        map->operator[](verb) = ae;
}



static animation_map_t *
getAnimationMap
(
void
)
{
        static smart_ptr<animation_map_t> s_map;
        if (!s_map) {
                // need to initialize!
                smart_ptr<animation_map_t> map = new animation_map_t;
                ASSERT(map, "null");

                // update
                addAnimation(map, "idle",       kLegsIdle,      kTorsoStand);
                addAnimation(map, "walk",       kLegsWalk,      kTorsoStand2);
                addAnimation(map, "run",        kLegsRun,       kTorsoStand2);

                // fully constructed
                s_map = map;
        }

        return s_map;
}



////////////////////////////////////////////////////////////////////////////////
//
//      PlayerTask - glut::Task object so it is possible to load Md3 models
//      on a separate thread, but delegate to the glut thread for any openGL
//      calls.  At the moment, *all* md3 model loading is delegated to the
//      open GL thread.  This is because we don't want to crack open the
//      original md3 model code.  That's probably a fine tradeoff for now.
//
////////////////////////////////////////////////////////////////////////////////

class PlayerTask : public glut::Task {
public:
        PlayerTask(IN const char * dir) {
                        m_dir = dir;
                }
        ~PlayerTask(void) throw() { }

        // public class methods ------------------------------------------------
        smart_ptr<Md3Player> getPlayer(void) { return m_player; }

        // glut::Task class interface methods ----------------------------------
        void doTask(void) {
                        m_player = new Md3Player(m_dir.c_str());
                        ASSERT(m_player, "null");

                        m_player->setAnimation(kTorsoStand);
                        m_player->setAnimation(kLegsIdle);
                }

private:
        std::string             m_dir;
        smart_ptr<Md3Player>    m_player;
};



////////////////////////////////////////////////////////////////////////////////
//
//      Player object -- wraps the Md3Player object with a glut::Renderable
//      interface.
//
////////////////////////////////////////////////////////////////////////////////

class Player : public glut::Renderable {
public:
        ~Player(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN const char * model_path);

        // glut::Renderable class interface methods ----------------------------
        void render(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq);
        rect3d_t getBoundingBox(void) const throw() { m_boundingBox.dump("MD3 DEBUG"); return m_boundingBox; }
        bool isAnimateable(void) const throw();
        void getAnimationState(OUT std::string& state);
        bool setAnimationState(IN const char * state);
        bool setAnimation(IN const char * verb);

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

        // private member functions --------------------------------------------
        void addState(IO glut::AnimationState& as,
                                IN eAnimationArea area);
        void setState(IN const glut::anim_channel_state_t& acs,
                                IN eAnimationArea area);

        // private member data -------------------------------------------------
        smart_ptr<Md3Player>            m_md3Player;
        rect3d_t                        m_boundingBox;
};



void
Player::initialize
(
IN const char * model_path
)
{
        ASSERT(model_path, "null");

        // wrap as a glut task
        PlayerTask task(model_path);

        // block until OpenGL thread handles this task
        glut::requestTask(&task);

        // okay, got it
        m_md3Player = task.getPlayer();
        ASSERT(m_md3Player, "failed to load player?");

        // now determine bounding box
        // TODO: need a way to do this!
        // For now, give it a generous window
        m_boundingBox.clear();
        m_boundingBox.inflate(1.5);     // basically a 3m cube
}



void
Player::render
(
IN const glut::render_context_t& rc,
IN glut::RenderQueue * rq
)
{
        ASSERT(rq, "null");

        glMatrixMode(GL_TEXTURE);
        glPushMatrix();

        // TODO: pull this out of here!  Just for testing...
        m_md3Player->animate(0.01);

        glEnable(GL_TEXTURE_2D);
        m_md3Player->draw();
        glDisable(GL_TEXTURE_2D);

        glMatrixMode(GL_TEXTURE);
        glPopMatrix();
}



bool
Player::isAnimateable
(
void
)
const
throw()
{
        return true;
}



void
Player::getAnimationState
(
OUT std::string& state
)
{
        glut::AnimationState as;

        addState(as, eAnimationArea_Upper);
        addState(as, eAnimationArea_Lower);
        as.serialize(state);

        //DPRINTF("State: '%s'", state.c_str());
}



bool
Player::setAnimationState
(
IN const char * state
)
{
        ASSERT(state, "null");

        glut::AnimationState as;
        if (!as.deserialize(state)) {
                DPRINTF("Unable to deserialize animation state?");
                DPRINTF("  state='%s'", state);
                return false;
        }

        // okay, update animation values!
        if (2 != as.size()) {
                DPRINTF("Only support 2-channel animation state");
                return false;
        }

        setState(as[0], eAnimationArea_Upper);
        setState(as[1], eAnimationArea_Lower);

        return true;
}



bool
Player::setAnimation
(
IN const char * verb
)
{
        ASSERT(verb, "null");
        ASSERT(m_md3Player, "null");

        animation_map_t * map = getAnimationMap();
        ASSERT(map, "failed to acquire animation map?");

        animation_map_t::const_iterator i = map->find(verb);
        if (map->end() == i) {
                DPRINTF("No such verb for md3 models: '%s'", verb);
                return false;
        }
        //DPRINTF("Setting animation verb: '%s'", verb);

        const anim_entry_t& ae = i->second;
        m_md3Player->setAnimation(ae.index1);
        m_md3Player->setAnimation(ae.index2);

        return true;
}



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

void
Player::addState
(
IO glut::AnimationState& as,
IN eAnimationArea area
)
{
        ASSERT(m_md3Player, "null");

        // get state from model
        Md3AnimState_t mas;
        m_md3Player->getAnimationState(area, mas);

        // map to general animation state
        glut::anim_channel_state_t acs;
        acs.animIndex = (int16_t) mas.animationIndex;
        acs.msElapsed = (int32_t) ((mas.time * 1000) + 0.5);

        // add
        as.push_back(acs);
}



void
Player::setState
(
IN const glut::anim_channel_state_t& acs,
IN eAnimationArea area
)
{
        ASSERT(m_md3Player, "null");

        Md3AnimState_t mas;

        mas.animationIndex = acs.animIndex;
        mas.time = 0.001 * acs.msElapsed;

        m_md3Player->setAnimationState(area, mas);
}



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

smart_ptr<glut::Renderable>
loadMd3Player
(
IN const char * model_path
)
{
        perf::Timer timer("loadMd3Model");
        ASSERT(model_path, "null");

        smart_ptr<Player> local = new Player;
        ASSERT(local, "null");

        local->initialize(model_path);

        return local;
}



};      // md3 namespace