obj-model/test/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2009,2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test the obj-model library.
 */

// includes --------------------------------------------------------------------
#include "glut-demo/glut-demo.h"
#include "obj-model/obj-model.h"
#include "perf/perf.h"
#include "util/file.h"


static int s_shape                              = 0;    // model
static const int s_maxShape                     = 2;
static float s_sphereRadius                     = 1.0;

static float s_scale                            = 1.0;


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

////////////////////////////////////////////////////////////////////////////////
//
//      display line objects
//
////////////////////////////////////////////////////////////////////////////////

class ShapeDisplay : public glut::DisplayLine {
public:
        // constructor, destructor ---------------------------------------------
        ~ShapeDisplay(void) throw() { }

        // glut::DisplayLine class interface methods ---------------------------
        ePosition getPosition(void) { return eTopLeft; }

        const char * getText(void) {
                        const char * txt = "???";
                        switch (s_shape) {
                        case 0: txt = "model";          break;
                        case 1: txt = "sphere";         break;
                        case 2: txt = "triangles";      break;
                        }

                        sprintf(m_buffer, "(s)hape: %s", txt);
                        return m_buffer;
                }

private:
        // private member data -------------------------------------------------
        char            m_buffer[256];
};




static void
setMaterials
(
void
)
{
        float d = 0.4;
        float diffuse[] = { d, d, d, 1.0 };
        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, diffuse);

        float s = 0.6;
        float specular[] = { s, s, s, 1.0 };
        glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
}



static void
drawTriangle
(
void
)
{
        setMaterials();

        float q = s_sphereRadius;
        float q2 = 0.5 * q;

        glBegin(GL_TRIANGLES);

        // front side
        glNormal3f(0, 0, 1);
        glVertex3f(-q, -q2, q);
        glVertex3f(+q, -q2, q);
        glVertex3f( 0, +q2, q);

        // back side
        glNormal3f(0, 0, -1);
        glVertex3f(+q, -q2, -q);
        glVertex3f(-q, -q2, -q);
        glVertex3f( 0, +q2, -q);

        // left side
        glNormal3f(-1, 0, 0);
        glVertex3f(-q, +q2, +q);
        glVertex3f(-q, +q2, -q);
        glVertex3f(-q, -q2, 0);

        // right side
        glNormal3f(+1, 0, 0);
        glVertex3f(+q, +q2, -q);
        glVertex3f(+q, +q2, +q);
        glVertex3f(+q, -q2, 0);

        glEnd();
}



static void
drawSphere
(
void
)
{
        setMaterials();

        int N = 32;
        glutSolidSphere(s_sphereRadius, N, N);
}



class TestHost : public glut::DemoHost {
public:
        TestHost(void) throw() { }
        ~TestHost(void) throw() { }

        // glut::Host class interface methods ----------------------------------
        void onInit(void) {
                // load model
                smart_ptr<nstream::Manager> mgr =
                    nstream::getFilesystemManager("/");
                ASSERT(mgr, "null");

                smart_ptr<nstream::File> file = mgr->getEntry(m_file.c_str());
                ASSERT_THROW(file, "Failed to find file: " << m_file);

                smart_ptr<nstream::Stream> stream = file->openStream();
                ASSERT_THROW(stream, "Failed to open stream: " << m_file);

                float scale = 1.0;
                m_model = obj::Model::create(stream, scale);
                ASSERT(m_model, "null");

                // figure out starting distance from center
                rect3d_t r = m_model->getBoundingBox();
                float dist = 0.0;
                dist += r.x1 - r.x0;
                dist += r.y1 - r.y0;
                dist += r.z1 - r.z0;
                dist *= .75;

                if (dist > 0) {
                        s_scale = 10.0 / dist;
                }

                // set sphere size and position
                s_sphereRadius = 2.0;
        }

        void getDisplayLines(IN glut::vec_display_lines_t& lines) {
                        lines.clear();

                        m_shapes = new ShapeDisplay;
                        THROW(m_shapes, "out of memory");
                        lines.push_back(m_shapes);
                }

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

                        // draw object
                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
                        switch (s_shape) {
                        case 0:
                        {
                                // translate model so it is centered on the origin
                                glScalef(s_scale, s_scale, s_scale);
                                rect3d_t r = m_model->getBoundingBox();
                                glTranslatef(-0.5 * (r.x0 + r.x1),
                                        -0.5 * (r.y0 + r.y1),
                                        -0.5 * (r.z0 + r.z1));
                                m_model->render(rc, rq);
                        }
                        break;

                        case 1:
                                drawSphere();
                                break;

                        case 2:
                                drawTriangle();
                                break;
                        }
                        glPopMatrix();
                }

        virtual void onKey(IN int key, IN int mods) {
                        switch (key) {
                        case 's':
                                s_shape++;
                                if (s_shape > s_maxShape) {
                                        s_shape = 0;
                                }
                                break;
                        }
                }

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

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

                        local->m_file = model_file;

                        return local;
                }

private:
        // private member data -------------------------------------------------
        std::string                     m_file;
        smart_ptr<obj::Model>           m_model;
        smart_ptr<ShapeDisplay>         m_shapes;
};



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "Usage: obj-model-test <model-file>");
        const char * model_file = argv[1];

        try {
                // create host object
                smart_ptr<glut::DemoHost> host = TestHost::create(model_file);
                THROW(host, "null");

                // ask glut to run
                const char * filename = GetFilename(model_file);
                std::string title = "obj-model test: ";
                title += filename;

                glut::startDemo(argc, argv, title.c_str(), host);

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

        return 1;       // never get here!
}