test2d.cpp

Go to the documentation of this file.

/*
 * test2d.cpp
 *
 * Copyright (C) 2009,2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test 2D glut drawing.
 */

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

#include "common/wave_ex.h"
#include "glut-font/glut-font.h"
#include "perf/perf.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 float s_dist                             = 10.0;


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

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

        // glut::Host class interface methods ----------------------------------
        void init(void) {
                // other initialization
                glShadeModel(GL_SMOOTH);

                glEnable(GL_LIGHT0);

                glFrontFace(GL_CCW);
                glCullFace(GL_BACK);
        }

        void display(IN int w, IN int h) {
                perf::time_t now = perf::getNow();
                static glut::fps_t s_fps(now);
                s_fps.tick(now);

                glEnable(GL_LIGHTING);
                glEnable(GL_DEPTH_TEST);
                glEnable(GL_TEXTURE_2D);
                glEnable(GL_CULL_FACE);

                // clear buffers (takes no effect until drawing much later)
                glClearColor(0.5, 0.5, 0.5, 1.0);
                glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

                // set up camera, viewer
                glut::camera_t camera;
                camera.setAspect(w, h);
                glut::Viewer viewer;
                viewer.setPosition(point3d_t(0, 0, -s_dist));

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

                // set up lighting
                float lightAmbient[] = { 0.8, 0.8, 0.8, 1.0 };
                glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmbient);

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

                // draw object
                glutSolidSphere(4.0, 16, 16);

                glDisable(GL_LIGHTING);
                glDisable(GL_DEPTH_TEST);
                glDisable(GL_TEXTURE_2D);
                glDisable(GL_CULL_FACE);
        
                glut::push2D(w, h);

                // rect
                glColor3f(0.8, 0.2, 0.8);
                for (int i = -10; i < 10; ++i) {
                        int x0 = i * 16;
                        int x1 = x0 + 14;
                        for (int j = -10; j < 10; ++j) {
                                int y0 = j * 12;
                                int y1 = y0 + 10;

                                glRecti(x0, y0, x1, y1);
                        }
                }

                // output FPS
                glut::Font * font = glut::getDefaultFont();
                glColor3f(1.0, 1.0, 1.0);
                char buffer[128];
                sprintf(buffer, "%d fps", (int) s_fps.getFPS());
                font->display(1, 12, 0, buffer);
                sprintf(buffer, "%d x %d", w, h);
                font->display(w - 100, 12, 0, buffer);

                glut::pop2D();
        }

        eBehavior tick(void) {
                return eContinue;
        }

        int shutdown(void) {
                perf::dumpTimingSummary(std::cout);
                return 0;
        }

        eBehavior keyboard(IN int key, IN int mods) {
                if ('=' == key)
                        s_dist += 1.0;
                if ('-' == key)
                        s_dist -= 1.0;
        
                if (s_dist < 1.0)
                        s_dist = 1.0;

                if ('l' == key)
                        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

                if ('s' == key)
                        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

                if (27 == key)
                        return eExit;

                return eContinue;
        }
};



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        try {
                // main loop
                smart_ptr<glut::Host> host = new Drawer;
                ASSERT(host, "out of memory");
                glut::start(argc, argv,
                        s_defaultWidth, s_defaultHeight,
                        "wave-glut md3 model viewer",
                        NULL,
                        host);

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

        // only reach here on error
        return 1;
}