wave-glut/lib/viewport/test/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Quick test of the viewport library
 */

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

#include "glut-demo/glut-demo.h"
#include "glut-font/glut-font.h"
#include "viewport/viewport.h"


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

static float
getRandomX
(
void
)
throw()
{
        const float invRand = 1.0 / RAND_MAX;

        return rand() * invRand;
}



class Viewer : public view::Host {
public:
        ~Viewer(void) throw() { }

        // view::Host class interface methods ----------------------------------
        void render3D(IN int id, IN const view::render_info_t& ri) {
                        glColor3f(m_color.red, m_color.green, m_color.blue);

                        perf::time_t newTime = perf::getNow();

                        perf::time_t delta = newTime;
                        delta.decrement(m_oldTime);

                        float deltaT = delta.getSeconds();
                        m_oldTime = newTime;

                        glut::camera_t camera;
                        camera.setAspect(ri.width, ri.height);
                        glMatrixMode(GL_PROJECTION);
                        glPushMatrix();
                        setOpenGLProjection(camera);

                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();

                        glLoadIdentity();
                        m_t += m_dt * deltaT;
                        float z = m_z + 5.0 * sin(m_t);
                        glTranslatef(0, 0, -z);

                        m_phi += m_dPhi * deltaT;
                        glRotatef(m_phi, 0, 1.0, 0);

                        // draw something resembling anything
                        int nIndex = id % 5;
                        switch (nIndex) {
                        case 0:         glutSolidCube(1.4);             break;
                        case 1:         glutSolidIcosahedron();         break;
                        case 2:         glutSolidSphere(1.0, 8, 8);     break;
                        case 3:         glutWireTeapot(1.0);            break;
                        case 4:         glutSolidTorus(0.4, 0.8, 16, 16); break;
                        default:
                                ASSERT(false, "unknown index: %d", nIndex);
                        }

                        glMatrixMode(GL_MODELVIEW);
                        glPopMatrix();
                        glMatrixMode(GL_PROJECTION);
                        glPopMatrix();
                }

        void render2D(IN int id, IN const view::render_info_t& ri) {
                //      DPRINTF("I am drawing in a window that is %d x %d",
                //          ri.width, ri.height);

                        glDisable(GL_LIGHTING);
                        glDisable(GL_BLEND);
                        glDisable(GL_TEXTURE_2D);
                        glDisable(GL_DEPTH_TEST);
                        glColor3f(1, 1, 1);
                        glut::Font * font = glut::getDefaultFont();
                        const int bufsize = 256;
                        char buffer[bufsize];
                        snprintf(buffer, bufsize, "Top of viewport %d", id);
                        font->display(1, 12, 0, buffer);
                        snprintf(buffer, bufsize, "Bottom of viewport %d", id);
                        font->display(1, ri.height - 4, 0, buffer);
                }

        // static factory methods ----------------------------------------------
        static smart_ptr<view::Host> create(void) {
                        smart_ptr<Viewer> local = new Viewer;
                        ASSERT(local, "out of memory");

                        local->initialize();

                        return local;
                }
private:
        // private helper methods ----------------------------------------------
        void initialize(void) {
                        m_color.red = 0.5 + 0.5 * getRandomX();
                        m_color.green = 0.5 + 0.5 * getRandomX();
                        m_color.blue = 0.5 + 0.5 * getRandomX();
                        m_color.alpha = 1.0;

                        m_z = 5.0 + 5.0 * getRandomX();

                        m_phi = 0.0;
                        m_dPhi = 180.0 * (getRandomX() - 0.5); // degrees/sec

                        m_t = 2.0 * M_PI * getRandomX();
                        m_dt = (0.5 + getRandomX());    // radians/sec

                        m_oldTime = perf::getNow();
                }

        // private member data -------------------------------------------------
        glut_color_t            m_color;
        float                   m_dPhi;
        float                   m_phi;
        float                   m_z;
        float                   m_t;
        float                   m_dt;
        perf::time_t            m_oldTime;
};



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

        // glut::DemoHost class interface methods ------------------------------
        void onInit(void) {
                        ASSERT_THROW(m_nViewports > 0, "Bad viewport count: " <<
                            m_nViewports);

                        int iStart = 1 + (rand() % 12);
                        m_viewMgr = view::Manager::create();
                        ASSERT_THROW(m_viewMgr, "null");
                        for (int i = 0; i < m_nViewports; ++i) {
                                smart_ptr<view::Host> viewer = Viewer::create();
                                ASSERT_THROW(viewer, "null");
                                m_viewMgr->createViewport(iStart + i, viewer);
                        }

                        DPRINTF("Created %d viewports",
                            m_viewMgr->getViewportCount());
                }

        bool displayAxes(void) { return false; }

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

                        int width = rc.viewport.right - rc.viewport.left;
                        int height = rc.viewport.bottom - rc.viewport.top;
                        m_viewMgr->render(width, height);
                }

        // static factory methods ----------------------------------------------
        static smart_ptr<glut::DemoHost> create(IN int nViewports) {
                        ASSERT_THROW(nViewports > 0, "Bad viewport count: " 
                            << nViewports);

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

                        local->m_nViewports = nViewports;

                        return local;
                }
private:
        // constructor ---------------------------------------------------------
        TestHost(void) throw() { }

        // private helper methods ----------------------------------------------
        // private member data -------------------------------------------------
        int                             m_nViewports;
        smart_ptr<view::Manager>        m_viewMgr;
};



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc,
            "Usage: viewport-test <viewport-count>");
        int nViewports = atoi(argv[1]);
        DPRINTF("Using %d viewports", nViewports);
        ASSERT(nViewports > 0, "Bad viewport count: %d", nViewports);

        int retval = 0;

        srand(time(NULL));

        try {
                perf::Timer timer("overall timer");

                // create demo host
                smart_ptr<glut::DemoHost> host = TestHost::create(nViewports);
                ASSERT_THROW(host, "null");

                const char * title = "Viewport Test";

                // start demo
                glut::startDemo(argc, argv, title, host);
                
        } catch (std::exception& e) {
                DPRINTF("EXCEPTION: %s", e.what());
                retval = 1;
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}