glut-demo.cpp

Go to the documentation of this file.

/*
 * glut-demo.cpp
 *
 * Copyright (C) 2010  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.
 *
 */

// includes --------------------------------------------------------------------
#include "glut-demo.h"          // always include our own header first

#include <iostream>
#include <math.h>

#include "glut-font/glut-font.h"
#include "perf/perf.h"
#include "util/date.h"
#include "wave-glut/glut_2d.h"


namespace glut {


// interface destructors
DisplayLine::~DisplayLine(void) throw() { }


// constants
static const int s_maxBufferSize                = 256;
static const int s_maxLighting                  = 3;
static const float s_dRot                       = 0.25; // degrees per frame
static const float s_2                          = sqrt(0.5);

static const float s_radiansPerDegree           = M_PI / 180.0;


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



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

class FpsDisplay : public DisplayLine {
public:
        // constructor, destructor ---------------------------------------------
        FpsDisplay(void) throw() : m_fps(perf::getNow()) { }
        ~FpsDisplay(void) throw() { }

        // public class methods ------------------------------------------------
        void tick(void) throw() {
                        m_fps.tick(perf::getNow());
                }

        // glut::DisplayLine class interface methods ---------------------------
        ePosition getPosition(void) { return eTopLeft; }
        const char * getText(void) {
                        int fps = (int) (m_fps.getFPS() + 0.5);
                        sprintf(m_buffer, "%d fps", fps);
                        return m_buffer;
                }

private:
        // private member data -------------------------------------------------
        char            m_buffer[s_maxBufferSize];
        fps_t           m_fps;  
};



class WireDisplay : public DisplayLine {
public:
        // constructor, destructor ---------------------------------------------
        WireDisplay(void) throw() : m_wire(false) { }
        ~WireDisplay(void) throw() { }

        // public class methods ------------------------------------------------
        void setWireframe(IN bool wireframe) throw() { m_wire = wireframe; }

        // glut::DisplayLine class interface methods ---------------------------
        ePosition getPosition(void) { return eTopLeft; }
        const char * getText(void) {
                        sprintf(m_buffer, "(w)ireframe: %s",
                            m_wire ? "yes" : "no");
                        return m_buffer;
                }

private:
        // private member data -------------------------------------------------
        char            m_buffer[s_maxBufferSize];
        bool            m_wire;
};



class LightingDisplay : public DisplayLine {
public:
        // constructor, destructor ---------------------------------------------
        LightingDisplay(void) throw() : m_light(0) { }
        ~LightingDisplay(void) throw() { }

        // public class methods ------------------------------------------------
        void setLighting(IN int level) throw() { m_light = level; }

        // glut::DisplayLine class interface methods ---------------------------
        ePosition getPosition(void) { return eTopRight; }
        const char * getText(void) {
                        const char * txt = "(unknown?)";
                        switch (m_light) {
                        case 0: txt = "none";                   break;
                        case 1: txt = "ambient only";           break;
                        case 2: txt = "ambient and directed";   break;
                        }
                        sprintf(m_buffer, "(l)ighting: %s", txt);
                        return m_buffer;
                }

private:
        // private member data -------------------------------------------------
        char            m_buffer[s_maxBufferSize];
        int             m_light;
};



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

        // public class methods ------------------------------------------------
        void setPosition(IN const point3d_t& pos) { m_pos = pos; }

        // glut::DisplayLine class interface methods ---------------------------
        ePosition getPosition(void) { return eTopRight; }
        const char * getText(void) {
                        sprintf(m_buffer, "position: (%.1f, %.1f, %.1f)",
                            m_pos.x, m_pos.y, m_pos.z);
                        return m_buffer;
                }

private:
        // private member data -------------------------------------------------
        char            m_buffer[s_maxBufferSize];
        point3d_t       m_pos;
};



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

        // public class methods ------------------------------------------------
        void setRotate(IN float dRot) throw() { m_rot = dRot; }

        // glut::DisplayLine class interface methods ---------------------------
        ePosition getPosition(void) { return eBottomRight; }
        const char * getText(void) {
                        sprintf(m_buffer, "(r/R)otate: %.2f degrees/frame",
                            m_rot);
                        return m_buffer;
                }

private:
        // private member data -------------------------------------------------
        char            m_buffer[s_maxBufferSize];
        float           m_rot;
};



////////////////////////////////////////////////////////////////////////////////
//
//      Demo - class that implements the glut::Host interface
//
////////////////////////////////////////////////////////////////////////////////

class Demo : public Host {
public:
        // constructor, destructor ---------------------------------------------
        Demo(void);
        ~Demo(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN DemoHost * host);

        // glut::Host class interface methods ----------------------------------
        void init(void);
        eBehavior tick(IN float dt);
        void display(IN int w, IN int h);
        eBehavior mouseMove(IN int x, IN int y);
        eBehavior mouseButton(IN int button, IN int state, IN int x, IN int y);
        eBehavior keyboard(IN int key, IN int mods);
        eBehavior specialKey(IN int key, IN int mods);
        int shutdown(void);

private:
        // private helper methods ----------------------------------------------
        void setLighting(void);
        void renderLines(IN int x, IN int y, IN int dy,
                                IN DisplayLine::ePosition pos);

        // private member data -------------------------------------------------
        DemoHost *              m_host;
        bool                    m_wireframe;    // render wireframe?
        int                     m_light;        // lighting level (0 - 2)
        float                   m_rot;          // rotations (degrees/frame)
        float                   m_angle;        // degrees, not radians
        float                   m_delta;
        Viewer                  m_viewer;
        vec_display_lines_t     m_lines;
        smart_ptr<glut::RenderQueue> m_rQueue;
        smart_ptr<perf::Timer>  m_demoTimer;
        smart_ptr<FpsDisplay>   m_fps;
        smart_ptr<WireDisplay>  m_wire;
        smart_ptr<LightingDisplay> m_lighting;
        smart_ptr<PositionDisplay> m_position;
        smart_ptr<RotateDisplay> m_rotate;
};



Demo::Demo(void)
:
m_host(NULL),
m_wireframe(false),
m_light(0),
m_rot(0.0),
m_angle(0.0)
{
}



Demo::~Demo(void)
throw()
{
}



void
Demo::initialize
(
IN DemoHost * host
)
{
        ASSERT(host, "null");
        m_host = host;

        m_demoTimer = new perf::Timer("glut demo overall timer");
        THROW(m_demoTimer, "null");

        m_viewer.setPosition(point3d_t(0, 0, -10));

        // get step size
        m_delta = host->getDelta();
        ASSERT(m_delta > 0.0, "Bad step size: %f", m_delta);

        // add our own display lines first
        m_fps = new FpsDisplay;
        THROW(m_fps, "out of memory");
        m_lines.push_back(m_fps);

        m_wire = new WireDisplay;
        THROW(m_wire, "out of memory");
        m_lines.push_back(m_wire);

        m_lighting = new LightingDisplay;
        THROW(m_lighting, "out of memory");
        m_lines.push_back(m_lighting);

        m_position = new PositionDisplay;
        THROW(m_position, "out of memory");
        m_lines.push_back(m_position);

        m_rotate = new RotateDisplay;
        THROW(m_rotate, "out of memory");
        m_lines.push_back(m_rotate);

        // append whatever the host wanted
        vec_display_lines_t lines;
        m_host->getDisplayLines(lines);
        m_lines.insert(m_lines.end(), lines.begin(), lines.end());
        DPRINTF("I have %d display lines", (int) m_lines.size());

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



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

void
Demo::init
(
void
)
{
        // let host do something
        m_host->onInit();
}



Host::eBehavior
Demo::tick
(
IN float dt
)
{
        ASSERT(dt >= 0.0, "bad time delta between frames: %f seconds", dt);

        m_host->onIdle(dt);

        return eContinue;
}



void
Demo::display
(
IN int w,
IN int h
)
{
        perf::Timer timer("Demo::display");
        ASSERT(m_rQueue, "null");

        // convenient hook
        m_delta = m_host->getDelta();

        // set up for 3D rendering
        m_fps->tick();
        m_wire->setWireframe(m_wireframe);
        m_lighting->setLighting(m_light);
        m_rotate->setRotate(m_rot);
        m_position->setPosition(m_viewer.getPosition());

        // basic capabilities
        glEnable(GL_DEPTH_TEST);
        glFrontFace(GL_CCW);    // counter clockwise is front

        // wireframe?  or polygon?
        if (m_wireframe) {
                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                glColor3f(1.0, 1.0, 1.0);
                glDisable(GL_CULL_FACE);
        } else {
                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                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);

        // rotate
        m_angle += m_rot;
        m_viewer.setYRotation(m_angle * s_radiansPerDegree);

        // set up camera, viewer
        render_context_t rc;
        rc.viewport.left = 0;
        rc.viewport.top = 0;
        rc.viewport.right = w;
        rc.viewport.bottom = h;
        rc.camera.setAspect(w, h);
        rc.viewer = m_viewer;

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

        // set lighting
        this->setLighting();

        // let host know
        {
                perf::Timer timer("host::display3D");
                m_host->display3D(rc, m_rQueue);
        }

        // draw axes
        if (m_host->displayAxes()) {
                glDisable(GL_LIGHTING);
                glColor3f(0, 0, 1);
                glBegin(GL_LINES);
                        glVertex3f(0, 1, 0);
                        glVertex3f(0, 2, 0);
                glEnd();

                glColor3f(1, 0, 0);
                glBegin(GL_LINES);
                        glVertex3f(1, 0, 0);
                        glVertex3f(2, 0, 0);
                glEnd();

                glColor3f(0, 1, 0);
                glBegin(GL_LINES);
                        glVertex3f(0, 0, 1);
                        glVertex3f(0, 0, 2);
                glEnd();
        }

        // now draw any queued polygons (transparencies)
        glEnable(GL_BLEND);
        glEnable(GL_LIGHTING);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_TEXTURE_2D);

        // save and clear transformation matrix
        //   (queued vertices should be pre-transformed)
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();

        // pop and draw all queued polygons
        if (m_host->displayQueuedPolys()) {
                perf::Timer timer("queued polygons");
                while (glut::poly_request_t * pr = m_rQueue->popRequest()) {
                        if (pr->nVertices < 3 || pr->textureId < 1) {
                                DPRINTF("Skipping invalid request");
                                continue;
                        }

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

        // done with queued polygons
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);
        glDisable(GL_LIGHT0);
        glDisable(GL_BLEND);
        glDisable(GL_CULL_FACE);
        glPopMatrix();

        // disable expensive 3D stuff
        glDisable(GL_DEPTH_TEST);

        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

        // set up for 2D rendering
        perf::Timer timer2d("demo--2D drawing");
        push2D(w, h);

        // let host know
        {
                perf::Timer timer("host::display2D");
                m_host->display2D(w, h);
        }

        // render display lines
        glColor3f(1, 1, 1);
        int textHeight = 14;
        int lineSpace = 2;
        int lineHeight = textHeight + lineSpace;
        int rightMargin = 300;
        this->renderLines(1, lineHeight, lineHeight,
            DisplayLine::eTopLeft);
        this->renderLines(w - rightMargin, lineHeight, lineHeight,
            DisplayLine::eTopRight);
        this->renderLines(1, h - lineSpace, -lineHeight,
            DisplayLine::eBottomLeft);
        this->renderLines(w - rightMargin, h - lineSpace, -lineHeight,
            DisplayLine::eBottomRight);

        // clean up
        pop2D();
}



int
Demo::shutdown
(
void
)
{
        // let the host know
        m_host->onShutdown();

        // close down
        m_demoTimer = NULL;
        perf::dumpTimingSummary(std::cerr);
        return 0;
}



Host::eBehavior
Demo::mouseMove
(
IN int x,
IN int y
)
{
        m_host->onCursor(x, y);
        return eContinue;
}



Host::eBehavior
Demo::mouseButton
(
IN int button,
IN int state,
IN int x,
IN int y
)
{
        m_host->onButton(button, state, x, y);
        return eContinue;
}



Host::eBehavior
Demo::keyboard
(
IN int key,
IN int mods
)
{
        switch (key) {
        case 'l':       m_light = (m_light + 1) % s_maxLighting;        break;

        case 'q':
        case 27:        // escape key
                return eExit;

        case 'r':       m_rot += s_dRot;                                break;

        case 'R':       m_rot -= s_dRot;                                break;

        case 'w':       m_wireframe = !m_wireframe;                     break;

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

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

        // let the host take a look
        m_host->onKey(key, mods);

        // all done
        return eContinue;
}



Host::eBehavior
Demo::specialKey
(
IN int key,
IN int mods
)
{
        // DPRINTF("mods = %d = 0x%08x", mods, mods);
        bool shiftDown = (1 & mods);

        const float s_up = 0.03;        // radians

        switch (key) {
        case GLUT_KEY_UP:
                if (shiftDown)
                        m_viewer.rotateUp(-s_up);
                else
                        m_viewer.move(0, 0, m_delta);   
                break;
        case GLUT_KEY_DOWN:
                if (shiftDown)
                        m_viewer.rotateUp(+s_up);
                else 
                        m_viewer.move(0, 0, -m_delta);
                break;
        case GLUT_KEY_LEFT:     m_viewer.move(0, -m_delta, 0);          break;
        case GLUT_KEY_RIGHT:    m_viewer.move(0, m_delta, 0);           break;
        }

        return eContinue;
}



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

void
Demo::setLighting
(
void
)
{
        // no lighting wanted?  quick exit...
        if (m_light < 1) {
                glDisable(GL_LIGHTING);
                glDisable(GL_LIGHT0);
                glDisable(GL_LIGHT1);
                return;
        }

        // some lighting is needed
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glShadeModel(GL_SMOOTH);

        // first light level: ambient white light
        float lightModelAmbient[] = { 0.2, 0.2, 0.2, 1.0 };
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightModelAmbient);
        if (m_light < 2)
                return;         // that's enough

        // second light level
        glEnable(GL_LIGHT1);
        float lightDirection[] = { s_2, 0, s_2, 0 };
        glLightfv(GL_LIGHT1, GL_POSITION, lightDirection);

        float lightDiffuse[] = { 1, 1, 1, 1 };
        glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse);
        glLightfv(GL_LIGHT1, GL_SPECULAR, lightDiffuse);

        float lightAmbient[] = { 0.2, 0, 0.2, 1 };
        glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient);
}



void
Demo::renderLines
(
IN int x,
IN int y,
IN int dy,
IN DisplayLine::ePosition pos
)
{
        glut::Font * font = glut::getDefaultFont();
        for (vec_display_lines_t::iterator i = m_lines.begin();
             i != m_lines.end(); ++i) {
                DisplayLine * pdl = *i;
                ASSERT(pdl, "null display line in vector");

                if (pdl->getPosition() != pos)
                        continue;       // line doesn't match position

                const char * txt = pdl->getText();
                font->display(x, y, 0, txt);
                y += dy;
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      DemoHost -- implementation
//
////////////////////////////////////////////////////////////////////////////////

DemoHost::~DemoHost(void)
throw()
{
}



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

void
startDemo
(
IN int argc,
IN const char * argv[],
IN const char * title,
IN DemoHost * host
)
{
        ASSERT(argc >= 0, "Bad argument count: %d", argc);
        IMPLIES(argc, argv, "null");
        ASSERT(title, "null");
        ASSERT(host, "null");

        // create a new Demo object to handle glut callbacks
        smart_ptr<Demo> demo = new Demo;
        THROW(demo, "out of memory");
        demo->initialize(host);

        int width = host->getWidth();
        int height = host->getHeight();

        // cast
        smart_ptr<Host> glutHost = demo;
        THROW(glutHost, "failed to downcast");
        glut::start(argc, argv, width, height, title, NULL, glutHost);
}



};      // glut namespace