libmini-test.cpp

Go to the documentation of this file.

/*
 * libmini-test.cpp
 *
 * Copyright (C) 2008,2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test the libmini library (terrain).
 */

// includes --------------------------------------------------------------------
#include <fstream>
#include <math.h>

#include "common/wave_ex.h"
#include "glut-font/glut-font.h"
#include "perf/perf.h"
#include "pgmppm/pgmppm.h"
#include "wave-glut/camera.h"
#include "wave-glut/glut_2d.h"
#include "wave-glut/wave-glut.h"

// include this last!
#include "terrain/mini.h"

static const int s_defaultWidth                 = 800;
static const int s_defaultHeight                = 600;

static int s_screenWidth                        = s_defaultWidth;
static int s_screenHeight                       = s_defaultHeight;


typedef short int height_t;

static int s_winid                              = -1;
static int s_wmode                              = 0;

// input delay
static const int s_delay                        = 100;
static int s_ignoreInput                        = s_delay;

// map data
static minitile * s_tileset                     = NULL;
static minicache * s_cache                      = NULL;
static int s_updates                            = 5;


static point3d_t s_lightPosition(0.0, 0.0, 0.0);
static point3d_t s_lightVelocity(0.0, 0.0, -0.01);

static int s_retval                             = 0;


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

static void
onExit
(
void
)
{
        // shut down windows etc
        glutDestroyWindow(s_winid);

        // display timing information
        std::string summary;
        perf::getTimingSummary(summary);
        DPRINTF("Timers:\n%s\n", summary.c_str());

        // exit!
        exit(s_retval);
}



static bool
notifyPgmSize
(
IN void * ctx,
IN int width,
IN int height,
IN int max_val
)
{
        int * pWidth = (int *) ctx;
        ASSERT(pWidth, "bad context");
        ASSERT(width > 0, "Bad pgm width: %d", width);
        ASSERT(height == width, "require height == width!");

        *pWidth = width;

        return false;   // don't bother loading the rest of the file!
}



static void
notifyPgmPixel
(
IN void * ctx,
IN int x,
IN int y,
IN int height
)
{
        // nothing to do!
}



static void
setTerrain
(
IN const char * pgm_file,
IN const char * ppm_file
)
{
        perf::Timer timer("setTerrain");
        ASSERT(pgm_file, "null");
        ASSERT(ppm_file, "null");

        DPRINTF("About to init...");
        float xzScale = 10.0;           // 10m
        float yScale = 1;               // 1m

        const char * hfield_files[] = { pgm_file };
        const char * texture_files[] = { ppm_file };

        // load pgm to determine size
        std::ifstream infile(hfield_files[0]);
        if (!infile.good()) {
                WAVE_EX(wex);
                wex << "Failed to open terrain file for reading: ";
                wex << hfield_files[0];
        }
        int width = -1;
        pgmppm::readPgm(infile, notifyPgmSize, notifyPgmPixel, &width);
        DPRINTF("PGM image width: %d pixels", width);
        ASSERT(width > 0, "Bad pgm width: %d", width);

        // dimension of heightfield?
        float dim = (width - 1) * xzScale;

        // okay, create minitile object
        int nRows = 1;
        int nCols = 1;
        s_tileset = new minitile((const unsigned char **) hfield_files,
                                 (const unsigned char **) texture_files,
                                 nRows, nCols,
                                 dim, dim, yScale);
        ASSERT(s_tileset, "null");

        s_cache = new minicache();
        ASSERT(s_cache, "out of memory");
        s_cache->attach(s_tileset);
}



static void
addLight
(
IN int gl_enum,
IN const point3d_t& position
)
{
        float x = position.x;
        float y = position.y;
        float z = position.z;

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

        float lightAmbient[] = { 0.2, 0.2, 0.2, 1.0 };
        glLightfv(gl_enum, GL_AMBIENT, lightAmbient);

        float str = 1.0;
        float lightDiffuse[] = { str, str / 3, str / 9, 1.0 };
        glLightfv(gl_enum, GL_DIFFUSE, lightDiffuse);
        glLightfv(gl_enum, GL_SPECULAR, lightDiffuse);

        glLightf(gl_enum, GL_QUADRATIC_ATTENUATION, .02);

        glColor3f(str, str / 3, str / 9);
        glPushMatrix();
        glTranslatef(x, y, z);
        glutSolidSphere(0.5, 8, 8);
        glPopMatrix();
}



static void
setLights
(
IN const glut::Viewer& walker
)
{
        // first light: ambient white light
        float lightAmbient[] = { 0.5, 0.5, 0.5, 1.0 };
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmbient);

        // other lights--moving
        s_lightPosition.increment(s_lightVelocity);
        s_lightPosition.y = mini::getheight(s_lightPosition.x, s_lightPosition.z);
        s_lightPosition.y += 5.0;
        addLight(GL_LIGHT0, s_lightPosition);

        addLight(GL_LIGHT1, walker.getPosition());

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



static void
debugInfo
(
IN const glut::Viewer& viewer
)
{
        DPRINTF("Debug Information");
        point3d_t v;

        v = viewer.getPosition();
        v.dump("  Viewer is at");
        DPRINTF("  mini says height at camera is: %f",
            mini::getheight(v.x, v.z));

        v = viewer.getFacing();
        v.dump("  Viewer is facing");
}



static void
updatePosition
(
IO glut::Viewer& view
)
{
        // get the current state of the first joystick
/*
        DPRINTF("stick1: (%4d, %4d)    stick2: (%4d, %4d)",
            joy.stick1.x, joy.stick1.y, joy.stick2.x, joy.stick2.y);
 */

/*
        // first axis: viewpoint
        float dr = 0.02;
        float dy_rot = (-joy.stick1.x * dr) / lib3d::eInput_MaxAxis;
        float dz_rot = (joy.stick1.y * dr) / lib3d::eInput_MaxAxis;
        view.rotateY(dy_rot);
        view.rotateUp(dz_rot);

        // second axis: motion
        float step = 0.1;
        float forward = (joy.stick2.y * step) / lib3d::eInput_MaxAxis;
        float sideways = (joy.stick2.x * step) / lib3d::eInput_MaxAxis;
        view.move(forward, sideways, 0.0);

        // get new location
        point3d_t pos = view.getPosition();
//      pos.dump("position");

*/
        // ignore input?
        if (s_ignoreInput) {
                s_ignoreInput--;
                return;
        }
/*
        // shoot out light?
        if (lib3d::eInput_Bumper1Top & joy.buttons) {
                s_lightPosition = pos;
                s_lightVelocity = view.getFacing();
                s_lightVelocity.scale(0.1);
                s_ignoreInput = s_delay;
        }

        // shoot out cube?
        if (lib3d::eInput_Bumper1Bottom & joy.buttons) {
                point3d_t pos = view.getPosition();
                pos.y += 2.0;
                point3d_t facing = view.getFacing();
                shootCube(pos, facing);
                s_ignoreInput = s_delay;
        }

*/
        // debug?
        if (0) {
                debugInfo(view);
                s_ignoreInput = s_delay;
        }
}



static void
onDisplay
(
void
)
{
        perf::Timer timer("onDisplay");

        static glut::Viewer viewer;
        static glut::camera_t camera;
        static float t = 0.0;
        const float dt = 0.002;
        t += dt;

        // update position based on controller
        updatePosition(viewer);
        viewer.setPosition(point3d_t(1000.0 * sin(0.1 * t), 0, 1000.0 * cos(0.1 * t)));
        point3d_t vpos = viewer.getPosition();
        float min_y = mini::getheight(vpos.x, vpos.z) + 10.0;
        float dy = (min_y - vpos.y);
        if (dy > 0.0) {
                viewer.move(0, 0, dy);
        }
//      camera.dump("camera");

        viewer.rotateY(0.5 * dt);

        // fps
        static glut::fps_t myFps(perf::getNow());
        myFps.tick(perf::getNow());

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

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

        // set perspective viewing (camera + projection)
        glut::setOpenGLProjection(camera);
        glut::setOpenGLViewer(viewer);

        // set up the lights (use default modelview transformation)
        glColor3f(1.0, 1.0, 1.0);
        if (s_updates) {
                glut::Viewer bogus = viewer;
                bogus.move(100.0, 0, 0);
                setLights(bogus);
        }

        // set up for drawing
        float resolution = 1000.0;
        point3d_t view = viewer.getFacing();
        point3d_t eye = viewer.getPosition();
        point3d_t up = viewer.getUp();

        glNormal3f(0.0, 1.0, 0.0);
        s_tileset->draw(resolution,
                            eye.x, eye.y, eye.z,
//                          eye.x, eye.y, eye.z,
                            view.x, view.y, view.z,
                            up.x, up.y, up.z,
                            camera.getFovy(),
                            camera.getAspect(),
                            camera.getZNear(),
                            camera.getZFar(),
                            s_updates);

        // actually draw
        s_cache->rendercache();

        // draw text
        // first, switch to orthographic projection
        glut::push2D(s_screenWidth, s_screenHeight);
        glColor3f(0, 0, 0);
        glut::Font * font = glut::getDefaultFont();
        char buffer[1024];
        sprintf(buffer, "%5.1f FPS", myFps.getFPS());
        font->display(10, 15, 0.0, buffer);
        glut::pop2D();

        // clear capabilities (just before exit!)
        glDisable(GL_COLOR_MATERIAL);
        glDisable(GL_DEPTH_TEST);

        // last thing--swap the buffers out
        glutSwapBuffers();
}



static void
onIdle
(
void
)
{
        glutPostRedisplay();
}



static void
onKeys
(
IN byte_t key,
IN int x,
IN int y
)
{
        DPRINTF("Pressed %d = '%c' at (%d, %d)", key, key, x, y);

        int mods = glutGetModifiers();
        if (GLUT_ACTIVE_SHIFT & mods) {
                DPRINTF("  'shift' is pressed");
        } else if (GLUT_ACTIVE_CTRL & mods) {
                DPRINTF("  'ctrl' is pressed");
        } else if (GLUT_ACTIVE_ALT & mods) {
                DPRINTF("  'alt' is pressed");
        }

        if ('w' == key) {
                s_wmode = 1 - s_wmode;
                if (s_wmode) {
                        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                } else {
                        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                }
        }

        if (27 == key || 'q' == key || 'Q' == key) {
                onExit();
        }
}



static void
onSpecial
(
IN int key,
IN int x,
IN int y
)
{
        DPRINTF("Pressed 0x%02x at (%d, %d)", key, x, y);
}



static void
onReshape
(
IN int w,
IN int h
)
{
        DPRINTF("Screen size: %d x %d", w, h);
        s_screenWidth = w;
        s_screenHeight = h;

        glViewport(0, 0, w, h);
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(3 == argc,
            "usage: mini-test <pgm-file> <ppm-file>");

        const char * pgm_file = argv[1];
        const char * ppm_file = argv[2];

        // initialize GLUT
        glutInit(&argc, (char **) argv);

        // initialize windows etc.
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
        glutInitWindowSize(s_defaultWidth, s_defaultHeight);
        s_winid = glutCreateWindow("test_glut");
        ASSERT(s_winid > 0, "Bad window id: %d", s_winid);

        // callbacks
        glutDisplayFunc(onDisplay);
        glutIdleFunc(onIdle);
        glutKeyboardFunc(onKeys);
        glutSpecialFunc(onSpecial);
        glutReshapeFunc(onReshape);
        glutCloseFunc(onExit);

        // NOTE: libmini apparently requires glut to be initialized before
        //      some of its library calls!  So initialize GL/GLUT first.
        try {

                setTerrain(pgm_file, ppm_file);

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

        // joysticks

        // main loop
        glutMainLoop();

        return 0;
}