main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 * Viewer for BVH files.
 */

////////////////////////////////////////////////////////////////////////////////
///
/// \ingroup tool
/// \defgroup tool_bvh_view OpenGL BVH Viewer
///
/// Simple OpenGL-based BVH file/animation viewer.
///
////////////////////////////////////////////////////////////////////////////////


// includes --------------------------------------------------------------------
#include "common/wave_ex.h"

#include "bvh/bvh.h"
#include "glut-font/glut-font.h"
#include "perf/perf.h"
#include "util/file.h"
#include "wave-glut/camera.h"
#include "wave-glut/glut_2d.h"
#include "wave-glut/wave-glut.h"


static const int s_defaultWidth                 = 800;
static const int s_defaultHeight                = 600;

static int s_retval                             = 0;

static float s_delta                            = 1;

static const float s_d2Rotate                   = 0.25;
static float s_dRotate                          = 0;

static const int s_maxLight                     = 4;

static int s_names                              = 0;    // no names

static int s_animSpeed                          = 0;
static int s_maxSpeed                           = 2;


static smart_ptr<perf::Timer> s_overallTimer;


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

static const char *
getSpeed
(
void
)
throw()
{
        switch (s_animSpeed) {
        case 0:         return "stopped";
        case 1:         return "slow";
        case 2:         return "normal";
        }

        return "bogus";
}



////////////////////////////////////////////////////////////////////////////////
//
//      BvhHost -- class that implements the glut::Host interface for the
//              BVH viewer
//
////////////////////////////////////////////////////////////////////////////////

class BvhHost : public glut::Host {
public:
        BvhHost(void) throw() : m_nodes(NULL) { }
        ~BvhHost(void) throw() { }

        // glut::Host class interface methods ----------------------------------
        void init(void);
        void display(IN int w, IN int h);
        int shutdown(void);
        eBehavior keyboard(IN int key, IN int mods);
        eBehavior specialKey(IN int key, IN int mods);

        // static factory methods ----------------------------------------------
        static smart_ptr<glut::Host> create(IN const char * directory) {
                        ASSERT(directory, "null");

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

                        local->m_dir = directory;

                        return local;
                }

private:
        // private helper methods ----------------------------------------------
        void loadSkeleton(void);
        void drawSkeleton(void);

        // private member data -------------------------------------------------
        std::string                     m_file;
        std::string                     m_dir;
        VecString                       m_files;
        int                             m_currFile;
        smart_ptr<bvh::Skeleton>        m_skeleton;
        glut::Viewer                    m_viewer;
        bvh::node_position_t *          m_nodes;
        int                             m_nNodes;
        perf::time_t                    m_prevTime;
        perf::time_t                    m_currTime;
        float                           m_animTime;
};



////////////////////////////////////////////////////////////////////////////////
//
//      BvhHost -- glut::Host class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
BvhHost::init
(
void
)
{
        // get all children
        walkDirectoryTree(m_dir.c_str(), "bvh", m_files);
        DPRINTF("Found %d BVH files", (int) m_files.size());

        // initialize iterator
        m_currFile = 0;

        // initialize
        this->loadSkeleton();

        // figure out starting distance from center

        // set starting position
        m_viewer.setPosition(point3d_t(0, 0, -100.0));
}


void
BvhHost::display
(
IN int width,
IN int height
)
{
        perf::Timer timer("display");

        // update previous time
        m_prevTime = m_currTime;

        // update FPS
        m_currTime = perf::getNow();
        static glut::fps_t s_fps(m_currTime);
        s_fps.tick(m_currTime);

        // clear buffers
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

        // set up glut for drawing
        glut::camera_t camera;
        glut::setOpenGLProjection(camera);
        glut::setOpenGLViewer(m_viewer);

        // rotate object
        static float angle = 0.0;
        angle += s_dRotate;
        glRotatef(angle, 0.0, 1.0, 0.0);

        // draw object
        this->drawSkeleton();

        // disable lighting
        glDisable(GL_LIGHTING);

        // draw axes
        glColor3f(0, 0, 1);     // blue: y
        glBegin(GL_LINES);
                glVertex3f(0, 1, 0);
                glVertex3f(0, 2, 0);
        glEnd();

        glColor3f(1, 0, 0);     // red: x
        glBegin(GL_LINES);
                glVertex3f(1, 0, 0);
                glVertex3f(2, 0, 0);
        glEnd();

        glColor3f(0, 1, 0);     // green: z
        glBegin(GL_LINES);
                glVertex3f(0, 0, 1);
                glVertex3f(0, 0, 2);
        glEnd();


        // disable expensive stuff before rendering fonts!
//      glDisable(GL_DEPTH_TEST);
//      glDisable(GL_BLEND);

        // output FPS
        int textHeight = 14;
        int lineSpace = 2;
        int lineHeight = textHeight + lineSpace;
        glColor3f(1.0, 1.0, 1.0);
        glut::push2D(width, height);
        char buffer[128];

        sprintf(buffer, "%s", m_file.c_str());
        glut::Font * font = glut::getDefaultFont();
        font->display(1, lineHeight, 0, buffer);

        sprintf(buffer, "%4.1lf fps", s_fps.getFPS());
        font->display(1, 2 * lineHeight, 0, buffer);

        sprintf(buffer, "(r/R)otate: %5.2lf degrees/frame", s_dRotate);
        font->display(width - 300, height - lineSpace, 0, buffer);

        sprintf(buffer, "(a)nimation time: %5.2fs (%s)", m_animTime, getSpeed());
        font->display(1, height - lineSpace, 0, buffer);

        sprintf(buffer, "(n)ames: %s", (s_names ? "yes" : "no"));
        font->display(1, height - lineHeight, 0, buffer);

        point3d_t pos = m_viewer.getPosition();
        sprintf(buffer, "position: (%f, %f, %f)", pos.x, pos.y, pos.z);
        font->display(width - 450, lineHeight, 0, buffer);

        glut::pop2D();
}



int
BvhHost::shutdown
(
void
)
{
        s_overallTimer = NULL;
        perf::dumpTimingSummary(std::cerr);
        return 0;
}



glut::Host::eBehavior
BvhHost::keyboard
(
IN int key,
IN int mods
)
{
        switch (key) {
        case 'q':
        case 27:                // escape key
                return eExit;

        case 'a':
                s_animSpeed++;
                if (s_animSpeed > s_maxSpeed) {
                        s_animSpeed = 0;
                }
                break;

        case 'r':
                s_dRotate += s_d2Rotate;
                break;

        case 'R':
                s_dRotate -= s_d2Rotate;
                break;

        case '+':
        case '=':
                m_viewer.move(s_delta, 0, 0);
                break;

        case '-':
                m_viewer.move(-s_delta, 0, 0);
                break;

        case 'n':
                s_names = 1 - s_names;
                break;
        }

        return eContinue;
}



glut::Host::eBehavior
BvhHost::specialKey
(
IN int key,
IN int mods
)
{
        int deltaF = 0;

        switch (key) {
        case GLUT_KEY_UP:
                m_viewer.move(0, 0, s_delta);
                break;

        case GLUT_KEY_DOWN:
                m_viewer.move(0, 0, -s_delta);
                break;

        case GLUT_KEY_LEFT:
                m_viewer.move(0, -s_delta, 0);
                break;

        case GLUT_KEY_RIGHT:
                m_viewer.move(0, s_delta, 0);
                break;

        case GLUT_KEY_PAGE_UP:
                deltaF = -1;
                break;

        case GLUT_KEY_PAGE_DOWN:
                deltaF = +1;
                break;

        }

        if (deltaF) {
                m_currFile += deltaF;
                if (m_currFile < 0) {
                        m_currFile = m_files.size() - 1;
                } else if (m_currFile >= (int) m_files.size()) {
                        m_currFile = 0;
                }
                this->loadSkeleton();
        }

        return eContinue;
}



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

void
BvhHost::loadSkeleton
(
void
)
{
        if (m_nodes) {
                delete[] m_nodes;
                m_nodes = NULL;
        }
        m_skeleton = NULL;
        m_currFile = m_currFile % m_files.size();

        // load skeleton
        m_file = m_files[m_currFile];

        std::string path = m_dir;
        path += "/";
        path += m_file;
        m_skeleton = bvh::Skeleton::load(path.c_str());
        ASSERT(m_skeleton, "null");
}



void
BvhHost::drawSkeleton
(
void
)
{
        perf::Timer timer("drawSkeleton");
        if (!m_skeleton)
                return;

        float deltaT = float(m_currTime.getSeconds() - m_prevTime.getSeconds());
        if (1 == s_animSpeed) {
                m_animTime += 0.2 * deltaT;
        } else if (2 == s_animSpeed) {
                m_animTime += deltaT;
        }

        // need to allocate node position array?
        if (!m_nodes) {
                m_nNodes = m_skeleton->getNodeCount(0);
                ASSERT(m_nNodes > 0, "bad node count: %d", m_nNodes);

                m_nodes = new bvh::node_position_t[m_nNodes];
                ASSERT(m_nodes, "out of memory");

                m_animTime = 0.0;
        }

        // update node positions given current time
        m_skeleton->getNodePositions(0, m_animTime, m_nodes);

        // first pass--get weighted average of center
        point3d_t avg(0, 0, 0);
        for (int i = 0; i < m_nNodes; ++i) {
                const bvh::node_position_t&n = m_nodes[i];
                avg += n.pos;
        }
        avg *= (1.0 / m_nNodes);
        avg.clear();

        // okay, now walk all nodes and draw!
        float dx = 0.25;                // sizing
        glut::Font * font = glut::getDefaultFont();
        for (int i = 0; i < m_nNodes; ++i) {
                const bvh::node_position_t&n = m_nodes[i];

                point3d_t r = n.pos - avg;

                // draw a small sphere here...
                glMatrixMode(GL_MODELVIEW);
                glPushMatrix();
                glColor3f(0.4, 0.4, 0.4);
                glTranslatef(r.x, r.y, r.z);
                glutSolidSphere(dx, 8, 8);
                glPopMatrix();

                if (s_names) {
                        glColor3f(0, 1, 0);
                        font->display(r.x, r.y, r.z, n.name);
                }

                // draw a line to the parent
                if (n.parent) {
                        point3d_t q = n.parent->pos - avg;

                        glColor3f(0.8, 0.3, 0.1);
                        glBegin(GL_LINES);
                        glVertex3f(q.x + dx, q.y, q.z);
                        glVertex3f(r.x + dx, r.y, r.z);
                        glVertex3f(q.x - dx, q.y, q.z);
                        glVertex3f(r.x - dx, r.y, r.z);
                        glVertex3f(q.x, q.y, q.z + dx);
                        glVertex3f(r.x, r.y, r.z + dx);
                        glVertex3f(q.x, q.y, q.z - dx);
                        glVertex3f(r.x, r.y, r.z - dx);
                        glVertex3f(q.x, q.y + dx, q.z);
                        glVertex3f(r.x, r.y + dx, r.z);
                        glVertex3f(q.x, q.y - dx, q.z);
                        glVertex3f(r.x, r.y - dx, r.z);
                        glEnd();
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "Usage: bvhViewer <directory>");
        const char * directory = argv[1];

        try {
                s_overallTimer = new perf::Timer("overall timer");
                ASSERT(s_overallTimer, "null");

                // create host object
                smart_ptr<glut::Host> host = BvhHost::create(directory);
                ASSERT(host, "null");

                // ask glut to run
                std::string title = "BVH Viewer: ";
                title += directory;

                glut::start(argc, argv, s_defaultWidth, s_defaultHeight,
                    title.c_str(), NULL, host);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                s_retval = 1;
        }

        return 1;       // never get here!
}