xform-model.cpp

Go to the documentation of this file.

/*
 * xform-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.
 *
 *
 * Transformation wrapper for other model types (see xform-model.h)
 */

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

#include "common/wave_ex.h"
#include "perf/perf.h"


namespace glut {



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


////////////////////////////////////////////////////////////////////////////////
//
//      XformModel -- class that implements the Renderable interface for
//              Open Asset Import library aiScene xformects.
//
////////////////////////////////////////////////////////////////////////////////

class XformModel : public Renderable {
public:
        // constructor, destructor ---------------------------------------------
        XformModel(void) throw();
        ~XformModel(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN const matrix4_t& xform,
                                IN smart_ptr<Renderable>& model);

        // glut::Renderable class interface methods ----------------------------
        rect3d_t getBoundingBox(void) const throw() { return m_bounds; }
        void render(IN const glut::render_context_t& rc,
                                IN RenderQueue * rq);
        bool isAnimateable(void) const throw();
        void getAnimationState(OUT std::string &state);
        bool setAnimationState(IN const char * state);
        void getAnimationVerbs(OUT VecString& verbs);
        bool setAnimation(IN const char * verb);

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

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

        // private member data -------------------------------------------------
        rect3d_t                        m_bounds;
        std::string                     m_timerName;
        matrix4_t                       m_xform;        // transformation
        matrix4_t                       m_xformTranspose;// transpose of xform
        smart_ptr<Renderable>           m_model;        // base model object
};



XformModel::XformModel
(
void
)
throw()
{
}



void
XformModel::initialize
(
IN const matrix4_t& xform,
IN smart_ptr<Renderable>& model
)
{
        ASSERT(model, "null");

        m_xform = xform;
        m_model = model;

        // keep a copy of the transposed matrix (handy for OpenGL glMultMatrix)
        m_xformTranspose = m_xform;
        m_xformTranspose.transpose();

        // TODO: transform bounding box!
        m_bounds = model->getBoundingBox();
}



void
XformModel::render
(
IN const glut::render_context_t& rc,
IN RenderQueue * rq
)
{
        perf::Timer timer(m_timerName.c_str());
        ASSERT(rq, "null");
        ASSERT(m_model, "null");

        // push state
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();

        // add our own transform
        glMultMatrixf(m_xformTranspose.m);

        // ask model to render
        m_model->render(rc, rq);

        // pop state
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
}



bool
XformModel::isAnimateable
(
void
)
const
throw()
{
        ASSERT(m_model, "null");

        return m_model->isAnimateable();
}



void
XformModel::getAnimationState
(
OUT std::string &state
)
{
        ASSERT(m_model, "null");

        m_model->getAnimationState(state);
}



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

        return m_model->setAnimationState(state);
}



void
XformModel::getAnimationVerbs
(
OUT VecString& verbs
)
{
        ASSERT(m_model, "null");

        return m_model->getAnimationVerbs(verbs);
}



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

        return m_model->setAnimation(verb);
}



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

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

smart_ptr<Renderable>
createXformModel
(
IN const matrix4_t& xform,
IN smart_ptr<Renderable>& model
)
{
        ASSERT(model, "null");

        smart_ptr<XformModel> local = new XformModel;
        ASSERT(local, "out of memory");

        local->initialize(xform, model);

        return local;
}



};      // glut namespace