glut-model/test/test.cpp

Go to the documentation of this file.

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

// includes --------------------------------------------------------------------
#include <iostream>
#include <fstream>

#include "common/wave_ex.h"
#include "glut-font/glut-font.h"
#include "glut-model/glut-model.h"
#include "perf/perf.h"
#include "util/file.h"
#include "util/token_stream.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_dist                             = 5.0;

static smart_ptr<perf::Timer> s_overallTimer;


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

static void
addLight
(
IN int gl_enum,
IN float L,
IN float x,
IN float y,
IN float z,
IN float r,
IN float g,
IN float b
)
{
        x *= L;
        y *= L;
        z *= L;

        float lightPos[] = { x, y, z, 1.0 };
        glLightfv(gl_enum, GL_POSITION, lightPos);

        float lightAmbient[] = { 0.1 + r, 0.1 + g, 0.1 + b, 1.0 };
        glLightfv(gl_enum, GL_AMBIENT, lightAmbient);

        float lightDiffuse[] = { 0.8 + r, 0.8 + g, 0.8 + b, 1.0 };
        glLightfv(gl_enum, GL_DIFFUSE, lightDiffuse);
        glLightfv(gl_enum, GL_SPECULAR, lightDiffuse);

        glLightf(gl_enum, GL_QUADRATIC_ATTENUATION, .1);

        glPushMatrix();
        glTranslatef(x, y, z);
        glutSolidSphere(1.0, 16, 16);
        glPopMatrix();
}



static void
setLights
(
void
)
{
        static float t = 0.0;
        t += 0.0075;

        float x = 0.5 * s_dist * cos(t);
        float y = 0;
        float z = 0.5 * s_dist * sin(t);

        // first light: ambient white light
        float lightAmbient[] = { 0.8, 0.8, 0.8, 1.0 };
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmbient);

        float ambientDir[] = { 1.0, 1.0, -1.0, 0.0 };
        glLightfv(GL_LIGHT0, GL_POSITION, ambientDir);

        // other lights--moving
        addLight(GL_LIGHT1, 6, x, y, z, 0, 0, 0.2);
//      addLight(GL_LIGHT2, 8, -x, y, z, 0.2, 0, 0);
//      addLight(GL_LIGHT3, 10, y, x, z, 0, 0.2, 0);

        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHT1);
//      glEnable(GL_LIGHT2);
}



static void
onDisplay
(
IN glut::Renderable * model,
IN glut::RenderQueue * rq
)
{
        perf::Timer timer("onDisplay");
        ASSERT(model, "null");
        ASSERT(rq, "null");

        perf::time_t now = perf::getNow();
        static glut::fps_t s_fps(now);
        s_fps.tick(now);

        //DPRINTF("On display...");
        // capabilities
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_COLOR_MATERIAL);

//      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

        glFrontFace(GL_CCW);    // counter clockwise is front
        glCullFace(GL_BACK);
        glEnable(GL_CULL_FACE);

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

        // set up camera, viewer
        glut::render_context_t rc;
        rc.viewer.setPosition(point3d_t(0, 0, -s_dist));

        // set up glut for drawing
        glut::setOpenGLProjection(rc.camera);
        glut::setOpenGLViewer(rc.viewer);

        // object materials
        float diffuse[] = { 0.8, 0.8, 0.8, 1.0 };
        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, diffuse);
        float specular[] = { 0.2, 0.2, 0.2, 1.0 };
        glMaterialfv(GL_FRONT, GL_SPECULAR, specular);

        // set up lighting
        setLights();

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

        // draw object
        model->render(rc, rq);

        // 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();

        // draw transparent (queued) textures
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        // first, save and clear the model view matrix
        // queued polygons should have pre-transformed vertices
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();       // reset modelview
        glEnable(GL_TEXTURE_2D);
        while (glut::poly_request_t * pr = rq->popRequest()) {
                ASSERT(pr, "null");
                DPRINTF("Drawing queued polygon!");

                if (pr->nVertices < 3) {
                        DPRINTF("Skipping polygon with %d vertices",
                            pr->nVertices);
                        continue;
                }
                if (pr->textureId < 1) {
                        DPRINTF("Skipping polygon with texture id %d",
                            pr->textureId);
                        continue;
                }

                // set up texture and normal
                glBindTexture(GL_TEXTURE_2D, pr->textureId);
                glNormal3fv((GLfloat *) &pr->normal.x);

                // send vertices
                glBegin(GL_POLYGON);
                for (int i = 0; i < pr->nVertices; ++i) {
                        glTexCoord2f(pr->u[i], pr->v[i]);
                        glVertex3fv((GLfloat *) &pr->vertex[i].x);
                }
                glEnd();
        }
        glDisable(GL_TEXTURE_2D);
        glPopMatrix();

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

        // output FPS
        glColor4f(1.0, 1.0, 1.0, 1.0);
        glut::push2D(s_defaultWidth, s_defaultHeight);
        char buffer[32];
        sprintf(buffer, "%4.1lf fps", s_fps.getFPS());
        glut::Font * font = glut::getDefaultFont();
        font->display(1, 16, 0, buffer);
        glut::pop2D();
}



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

        // glut::Host class interface methods ----------------------------------
        void init(void) {

                // get material directory
                std::string material_dir;
                GetParentDirectory(m_file.c_str(), material_dir);
                DPRINTF("Material directory: %s", material_dir.c_str());

                // material loader/registry
                m_registry = glut::getSimpleRegistry(material_dir.c_str());
                ASSERT(m_registry, "null");

                // load file
                std::ifstream stream(m_file.c_str());
                if (!stream.good()) {
                        WAVE_EX(wex);
                        wex << "failed to open file for reading: ";
                        wex << m_file;
                }
                glut::parseLodModel(m_registry, stream, m_model);

                // get distance
                rect3d_t r = m_model.getBoundingBox();
                s_dist = 2.0 * r.getDiagonal();

                // create render queue
                int nSlots = 16;
                m_rQueue = glut::RenderQueue::create(nSlots);
                ASSERT(m_rQueue, "failed to create render queue");
        }

        void display(IN int w, IN int h) {
                        onDisplay(&m_model, m_rQueue);
                }

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

        // static factory methods ----------------------------------------------
        static smart_ptr<glut::Host> 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<glut::MaterialRegistry> m_registry;
        smart_ptr<glut::RenderQueue>    m_rQueue;
        glut::lod_model_t               m_model;
};



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

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

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

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

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

                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!
}