terrain/test/test.cpp

Go to the documentation of this file.

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

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

#include "common/wave_ex.h"
#include "glut-font/glut-font.h"
#include "perf/perf.h"
#include "terrain/terrain.h"
#include "util/file.h"
#include "wave-glut/glut-state.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 int s_screenWidth                        = s_defaultWidth;
static int s_screenHeight                       = s_defaultHeight;

static const float s_twoPi                      = 2.0 * M_PI;

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_wmode                              = 0;

// lighting data
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;

// terrain
static smart_ptr<hfield::Heightfield> s_hfield;
static smart_ptr<glut::Renderable> s_terrain;


////////////////////////////////////////////////////////////////////////////////
//
//      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 void
setTerrain
(
IN const char * hfield_file
)
{
        perf::Timer timer("setTerrain");
        ASSERT(hfield_file, "null");

        // filesystem
        smart_ptr<nstream::Manager> mgr =
            nstream::getFilesystemManager("");
        ASSERT(mgr, "null");

        // create heightfield
        smart_ptr<nstream::Stream> stream =
            nstream::openNamedStream(mgr, hfield_file);
        ASSERT(stream, "null");
        s_hfield = hfield::Heightfield::create(stream);
        ASSERT(s_hfield, "Failed to load heightfield from file");
        s_hfield->dump(hfield_file);

        // create terrain object (hfield renderer) from hfield object
        s_terrain = glut::createTerrain(s_hfield);
        ASSERT(s_terrain, "failed to create terrain object");
}



static void
setLight
(
IN float t
)
{
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glShadeModel(GL_SMOOTH);

        // first light: ambient white light
        float lightModel[] = { 0.2, 0.2, 0.2, 1.0 };
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightModel);

        float lightPos[] = { sin(t), cos(t), 0, 0 };
        glLightfv(GL_LIGHT0, GL_POSITION, lightPos);

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

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



static void
onDisplay
(
IN glut::RenderQueue * rq
)
{
        perf::Timer timer("onDisplay");
        ASSERT(rq, "null");

        static float t = 0.0;
        const float dt = 0.002;
        t += dt;

        float xzScale = s_hfield->getXZScale();
        float W = xzScale * s_hfield->getWidth();
        float H = xzScale * s_hfield->getLength();
        
        float T = s_hfield->getMaxHeight() - s_hfield->getMinHeight();

        // update position based on controller
        float K = 2;
        point3d_t pos(sin(K * t), 0, sin((37 / 17) * K * (t + 0.2)));
        pos = 0.8 * W * pos;

        // set up position etc
        glut::render_context_t rc;
        rc.viewer.setPosition(pos);
        point3d_t vpos = rc.viewer.getPosition();
//      float min_y = s_hfield->getHeight(vpos.x, vpos.z) + 100.0;

        float hX = vpos.x + 0.5 * W;    // x-coordinate relative to hfield
        float hZ = vpos.z + 0.5 * H;    // z-coordinate relative to hfield
        float min_y = s_hfield->getHeight(hX, hZ) + 0.1 * (1.0 + sin(0.8773 * t)) * (W + 0.25 * T);
        float dy = (min_y - vpos.y);
        rc.viewer.move(0, 0, dy);
//      camera.dump("camera");

//      viewer.getPosition().dump("position");

        vpos = rc.viewer.getPosition();
        float R2 = dotProduct(vpos, vpos);
        float R = sqrt(R2);

        // always look at center!
        float phi = atan2(-vpos.x, -vpos.z);
        while (phi < 0.0) {
                phi += s_twoPi;
        }
        while (phi > s_twoPi) {
                phi -= s_twoPi;
        }

        float rho = asin(-vpos.y / R);
//      DPRINTF("x=%8.2f   z=%8.2f   y=%8.2f   phi=%5.2f   rho=%5.2f",
//          vpos.x, vpos.z, vpos.y,  phi, rho);

//      float phi = 0;
        rc.viewer.setYRotation(phi);
        rc.viewer.setUpRotation(rho);

//      point3d_t facing = viewer.getFacing();
//      facing.dump("facing");

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

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

        // 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);

        if (s_wmode) {
                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        } else {
                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        }

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

        // set up the lights (use default modelview transformation)
        glColor3f(1.0, 1.0, 1.0);
        setLight(t);

        // draw terrain
        glEnable(GL_COLOR_MATERIAL);
        s_terrain->render(rc, rq);
        glDisable(GL_COLOR_MATERIAL);

        // clear capabilities (just before text)
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);
        {
                perf::Timer timer("display-2d");
        // 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();
        }
}


/*
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");
        }
}
*/



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

        // glut::Host class interface methods ----------------------------------
        void init(void) {
                        setTerrain(m_hfieldFilename.c_str());

                        int nSlots = 8;
                        m_rQueue = glut::RenderQueue::create(nSlots);
                        ASSERT(m_rQueue, "null");
                }
        void display(IN int w, IN int h) {
                        onDisplay(m_rQueue);
                }
        int shutdown(void) {
                        onExit();
                        return 0;
                }
        eBehavior keyboard(IN int key, IN int mods) {
                        switch (key) {
                        case 'w':
                                s_wmode = 1 - s_wmode;
                                break;

                        case 27:
                        case 'q':
                                return eExit;
                        }

                        return eContinue;
                }

        // static factory methods ----------------------------------------------
        static smart_ptr<glut::Host> create(IN const char * hfieldFilename) {
                        ASSERT(hfieldFilename, "null");

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

                        local->m_hfieldFilename = hfieldFilename;

                        return local;
                }

private:
        // private member data -------------------------------------------------
        std::string             m_hfieldFilename;
        smart_ptr<glut::RenderQueue> m_rQueue;
};



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc,
            "usage: terrain-test <hfield-file>");

        const char * hfield_file = argv[1];

        try {

                smart_ptr<glut::Host> host = TestHost::create(hfield_file);
                ASSERT(host, "NULL");

                std::string title = "Terrain Test: ";
                title += GetFilename(hfield_file);

                glut::start(argc, argv, s_defaultWidth, s_defaultHeight,
                    title.c_str(), NULL, host);

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

        return 0;
}