wave-glut.cpp

Go to the documentation of this file.

/*
 * wave-glut.cpp
 *
 * Copyright (C) 2009,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.
 *
 *
 * See wave-glut.h
 */

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

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "threadsafe/smart_ptr.h"
#include "threadsafe/threadsafe.h"
#include "threadsafe/threadsafe_map.h"


namespace glut {


// interface destructors
Host::~Host(void) throw() { }
Task::~Task(void) throw() { }


struct task_record_t {
        // constructor, manipulators
        task_record_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        task = NULL;
                        exception = "";
                        needThrow = false;
                }

        // data fields
        Task *          task;
        std::string     exception;
        bool            needThrow;
};



// statics
typedef threadsafe_map<thread_id_t, smart_ptr<task_record_t> > task_map_t;

static task_map_t s_pendingTasks;
static task_map_t s_completedTasks;

// weirdly, WIN32 builds have a token named "s_host" defined already (!?)
#ifdef s_host
#undef s_host
#endif  // s_host

static smart_ptr<Host> s_host;
static bool s_fullscreen                = false;
static thread_id_t s_glutThreadId       = 0;

// glut window height, width
static int s_width                      = 0;
static int s_height                     = 0;


////////////////////////////////////////////////////////////////////////////////
//
//      Task-related methods
//
////////////////////////////////////////////////////////////////////////////////

void
processTasks
(
void
)
{
        // loop through and process all pending tasks
        task_map_t::iterator_t i;
        s_pendingTasks.getIterator(i);
        thread_id_t t_id;               // thread identifier
        smart_ptr<task_record_t> trec;
        while (s_pendingTasks.getNextElement(i, t_id, trec)) {
                ASSERT(trec, "null task record in map");
                ASSERT(trec->task, "null task in record");

                try {
                        trec->task->doTask();
                } catch (std::exception& e) {
                        trec->needThrow = true;
                        trec->exception = e.what();
                }

                // remove from pending map, add to completed
                // NOTE: order is important!  There is a slim chance that a
                // waiting thread could pull the completed task right away.
                // If we nuke the pending task afterwards, there is a chance
                // that the same thread will attempt to re-insert.  By adding
                // to the completed tasks last, we ensure that the waiting
                // thread won't do anything until we are done.
                s_pendingTasks.remove(t_id);
                s_completedTasks.insert(t_id, trec);
        }
}


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods (glut callbacks)
//
////////////////////////////////////////////////////////////////////////////////

static void
onExit
(
void
)
{
        // exit game mode
        if (s_fullscreen) {
                perf::Timer timer("glutLeaveGameMode");
                glutLeaveGameMode();
        }

        // have the host shut down, and destroy it
        ASSERT(s_host, "null");
        int retval = 1;
        try {
                retval = s_host->shutdown();
        } catch (std::exception& e) {
                DPRINTF("Exception during shutdown!");
                DPRINTF("%s", e.what());
        }
        s_host = NULL;

        exit(retval);
}



static void
onDisplay
(
void
)
{
        perf::Timer timer("glut::onDisplay");
        ASSERT(s_host, "null");

        // set up the viewport
        glViewport(0, 0, s_width, s_height);

        // tell the host
        try {
                s_host->display(s_width, s_height);
        } catch (std::exception& e) {
                DPRINTF("Exception while rendering!");
                DPRINTF("%s", e.what());
        }

        // swap buffers out
        glutSwapBuffers();
}



static void
onIdle
(
void
)
{
        perf::Timer timer("glut::onIdle");
        ASSERT(s_host, "null");

        // process any pending tasks
        glut::processTasks();

        // keep track of time delta since last onIdle() call
        static perf::time_t s_time = perf::getNow();
        perf::time_t now = perf::getNow();
        now.decrement(s_time);
        float dt = now.getSeconds();
        if (dt < 0.0) {
                dt = 0.0;
        }
        now.increment(s_time);
        s_time = now;

        Host::eBehavior behave = Host::eContinue;
        try {
                behave = s_host->tick(dt);
        } catch (std::exception& e) {
                behave = Host::eExit;
                DPRINTF("Exception during tick!");
                DPRINTF("%s", e.what());
        }

        if (Host::eContinue != behave)
                onExit();

        // request redraw
        glutPostRedisplay();
}



static void
onMouseButton
(
IN int button,
IN int state,
IN int x,
IN int y
)
{
        ASSERT(s_host, "null");

        Host::eBehavior behave = Host::eContinue;
        try {
                behave = s_host->mouseButton(button, state, x, y);
        } catch (std::exception& e) {
                DPRINTF("Exception procesing mouse button event");
                DPRINTF("%s", e.what());
        }

        if (Host::eContinue != behave) {
                onExit();
        }
}



static void
onMouseMove
(
IN int x,
IN int y
)
{
        ASSERT(s_host, "null");

        Host::eBehavior behave = Host::eContinue;
        try {
                behave = s_host->mouseMove(x, y);
        } catch (std::exception& e) {
                DPRINTF("Exception procesing mouse button event");
                DPRINTF("%s", e.what());
        }

        if (Host::eContinue != behave) {
                onExit();
        }
}



static void
onKeyboard
(
IN byte_t key,
IN int x,
IN int y
)
{
        ASSERT(s_host, "null");

        int mods = glutGetModifiers();

        Host::eBehavior behave = Host::eContinue;
        try {
                behave = s_host->keyboard(key, mods);
        } catch (std::exception& e) {
                DPRINTF("Exception processing keyboard event!");
                DPRINTF("%s", e.what());
        }

        if (Host::eContinue != behave)
                onExit();
}



static void
onSpecialKeys
(
IN int key,
IN int x,
IN int y
)
{
        ASSERT(s_host, "null");

        int mods = glutGetModifiers();

        Host::eBehavior behave = Host::eContinue;
        try {
                behave = s_host->specialKey(key, mods);
        } catch (std::exception& e) {
                DPRINTF("Exception processing special key!");
                DPRINTF("%s", e.what());
        }

        if (Host::eContinue != behave)
                onExit();
}



static void
onReshape
(
IN int w,
IN int h
)
{
        DPRINTF("Window size: %d x %d", w, h);

        s_width = w;
        s_height = h;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API (glut setup + running)
//
////////////////////////////////////////////////////////////////////////////////

void
start
(
IN int argc,
IN const char * argv[],
IN int width,
IN int height,
IN const char * title,
IN const char * gameModeString,
IN smart_ptr<Host>& host
)
{
        ASSERT(width > 0, "Bad width: %d", width);
        ASSERT(height > 0, "Bad height: %d", height);
        ASSERT(title, "null");
        // ASSERT(gameModeString) -- can be null!
        ASSERT(host, "null");

        // any standard validation we need to perform?
        ASSERT(sizeof(float) == sizeof(GLfloat),
            "Big problems: we don't agree with OpenGL on sizeof(float)!");
        ASSERT(sizeof(double) == sizeof(GLdouble),
            "Big problems: we don't agree with OpenGL on sizeof(double)!");
        ASSERT(sizeof(byte_t) == sizeof(GLbyte),
            "Big problems: we don't agree with OpenGL on sizeof(byte)!");
        ASSERT(sizeof(int) == sizeof(GLuint),
            "Big problems: we don't agree with OpenGL on sizeof(int)!");

        // remember host
        ASSERT(!s_host, "Already have a host");
        s_host = host;

        // remember thread
        s_glutThreadId = getCurrentThreadId();

        // start glut (double-buffering, alpha support, depth buffer)
        glutInit(&argc, (char **) argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);

        // try fullscreen if asked, and then fall back to windowed mode
        ASSERT(!s_fullscreen, "already in fullscreen mode?");
        if (0 && gameModeString) {
                DPRINTF("game mode string: '%s'", gameModeString);
                {
                        perf::Timer timer("glutEnterGameMode");
                        glutGameModeString(gameModeString);
                        s_fullscreen = glutEnterGameMode() ? true : false;
                }
                if (!s_fullscreen) {
                        DPRINTF("Failed to enter game mode!");
                        DPRINTF("  Falling back to windowed mode...");
                }
        }
        if (!s_fullscreen) {
                s_width = width;
                s_height = height;
                glutInitWindowSize(width, height);
                int win_id = glutCreateWindow(title);
                ASSERT(win_id > 0, "Bad window id: %d", win_id);
        }

        // initialize GLEW
        GLenum err = glewInit();
        if (GLEW_OK != err) {
                WAVE_EX(wex);
                wex << "Failed to initialize glew: ";
                wex << glewGetErrorString(err);
        }

        // register callbacks
        glutDisplayFunc(onDisplay);
        glutIdleFunc(onIdle);
        glutKeyboardFunc(onKeyboard);
        glutSpecialFunc(onSpecialKeys);
        glutReshapeFunc(onReshape);
        glutMouseFunc(onMouseButton);
        glutMotionFunc(onMouseMove);
        //glutPassiveMotionFunc(onMouseMove);
        glutCloseFunc(onExit);

        // sync to vertical retrace
#ifdef WIN32
        wglSwapIntervalEXT(1);
#else   // WIN32
        glXSwapIntervalSGI(1);
#endif  // WIN32

        // now that we're all initialized, let host know
        s_host->init();

        // enter main loop!
        glutMainLoop();
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API (tasks)
//
////////////////////////////////////////////////////////////////////////////////

void
requestTask
(
IO Task * task
)
{
        ASSERT(task, "null task passed to requestTask()");

        thread_id_t t_id = getCurrentThreadId();  // what is our thread id?
        if (t_id == s_glutThreadId) {
                // this is already the open gl thread!  No need to block
                task->doTask();
                return;
        }

        // we are not the open GL thread!  Need to synchronize
        // First, verify we don't already have a request pending
        smart_ptr<task_record_t> trec;
        ASSERT(!s_pendingTasks.lookup(t_id, trec),
            "Thread already has a pending task?");
        ASSERT(!s_completedTasks.lookup(t_id, trec),
            "Thread already has a completed task?");

        // okay, add to pending tasks
        trec = new task_record_t;
        ASSERT(trec, "out of memory");
        trec->task = task;
        s_pendingTasks.insert(t_id, trec);

        // now block on result!
        while (!s_completedTasks.lookup(t_id, trec)) {
                sleep(0);
        }
        ASSERT(trec, "received null record from completed task map");
        s_completedTasks.remove(t_id);

        // should we throw?
        if (trec->needThrow) {
                WAVE_EX(wex);
                wex << trec->exception;
        }
}



void
drawRectLines
(
IN const rect3d_t& r,
IN const glut_color_t& c
)
throw()
{
        glColor4bv((GLbyte *) &c);
        glBegin(GL_LINES);
        point3d_t p0, p1;
        for (int i = 0; i < rect3d_t::eMaxEdges; ++i) {
                r.getEdge(i, p0, p1);
                glVertex3fv((GLfloat *) &p0.x);
                glVertex3fv((GLfloat *) &p1.x);
        }
        glEnd();
}



void
getModelViewMatrix
(
OUT matrix4_t& T
)
throw()
{
        glGetFloatv(GL_MODELVIEW_MATRIX, T.m);
        T.transpose();
}



};      // glut namespace