terrain.cpp

Go to the documentation of this file.

/*
 * terrain.cpp
 *
 * Copyright (C) 2008,2009  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.
 *
 * Object that uses libmini to render heightfields
 */

// includes --------------------------------------------------------------------
#include "terrain.h"            // always include our own header first

#include "common/wave_ex.h"
#include "nstream/nstream.h"
#include "perf/perf.h"
#include "util/file.h"          // pathname manipulations
#include "wave-glut/glut-state.h"
#include "wave-glut/wave-glut.h"

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


namespace glut {




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

class Terrain : public Renderable {
public:
        // constructor, destructor ---------------------------------------------
        Terrain(void) throw() { }
        ~Terrain(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN hfield::Heightfield * hfield);

        // glut::Renderable class interface methods ----------------------------
        void render(IN const render_context_t& rc,
                                IN RenderQueue * rq);
        rect3d_t getBoundingBox(void) const throw() { return m_boundingBox; }

private:
        // private member data -------------------------------------------------
        smart_ptr<minitile>             m_tileset;
        smart_ptr<minicache>            m_cache;
        point3d_t                       m_offset;
        rect3d_t                        m_boundingBox;
        float                           m_yOffset;
};



void
Terrain::initialize
(
IN hfield::Heightfield * hfield
)
{
        perf::Timer timer("Terrain::initialize");
        ASSERT(hfield, "null");

        hfield->dump("Creating terrain rendering object");

        // reset a bunch of opengl stuff
        glPushMatrix();
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        // reset normal to default
        glNormal3f(0, 0, 1.0);

        // clear any texture binding
        glBindTexture(GL_TEXTURE_2D, 0);

        int iOldMode;
        glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &iOldMode);
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

        int iOldMinFilter;
        glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &iOldMinFilter);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);

        // dump openGL state
//      smart_ptr<glut::State> state = glut::State::snapshotFromOpenGL();
//      ASSERT(state, "null");
        //state->dump("state");

        // here we construct all the necessary libmini objects
        // NOTE: someday we may support multiple tiles in a model!  See
        // the libmini minitile documentation.  But for now we only support
        // 1x1 tilesets.
        int nRows = 1;
        int nCols = 1;

        const char * pgmFile = hfield->getHeightfieldPath();
        ASSERT(pgmFile, "null heightfield file?");

        const char * ppmFile = hfield->getTexturePath();
        ASSERT(ppmFile, "null texture file?");

        // get absolute paths
        smart_ptr<nstream::Manager> mgr = hfield->getStreamManager();
        ASSERT_THROW(mgr, "null");
        std::string pgmAbs = mgr->getFullName(pgmFile);
        std::string ppmAbs = mgr->getFullName(ppmFile);

        DPRINTF("height file:  %s", pgmAbs.c_str());
        DPRINTF("texture file: %s", ppmAbs.c_str());

        const char * hfield_files[] = { pgmAbs.c_str() };
        const char * texture_files[] = { ppmAbs.c_str() };

        int width = hfield->getWidth();         // grid points in x-direction
        int length = hfield->getLength();       // grid points in z-direction
        ASSERT(width > 0 && length > 0,
            "Bad width or length?  w=%d, h=%d", width, length);

        ASSERT(width == length, "libmini requires width = length!");

        float xzScale = hfield->getXZScale();
        ASSERT(xzScale > 0, "Bad xz-scale: %f", xzScale);

        float xSize = (width - 1) * xzScale;
        float zSize = (length - 1) * xzScale;

        float yScale = hfield->getYScale();
        ASSERT(yScale > 0, "Bad y-scale: %f", yScale);

        // create tileset (1x1, see above) based on heightfield data
        ASSERT(!m_tileset, "Already have a tileset?");
        m_tileset = new minitile((const unsigned char **) hfield_files,
                                 (const unsigned char **) texture_files,
                                 nRows, nCols, xSize, zSize, yScale);
        ASSERT(m_tileset, "out of memory");

        // create a minicache for faster rendering
        ASSERT(!m_cache, "already have a cache?");
        m_cache = new minicache();
        ASSERT(m_cache, "out of memory");

        // initialize cache
        m_cache->attach(m_tileset);
        m_cache->usevtxshader(0);

        // set up bounding box
        m_boundingBox.clear();
        m_boundingBox.x1 = xSize;
        m_boundingBox.z1 = zSize;
        m_boundingBox.y0 = hfield->getMinHeight() * yScale;
        m_boundingBox.y1 = hfield->getMaxHeight() * yScale;
        m_boundingBox.dump("Raw bounding box (from native heightfield)");

        // calculate offset
        // There is an annoyance in how terrain coordinates are determined!
        // Bullet ignores terrain coordinates, and automatically centers
        //   heightfields in their bounding box.  This is probably appropriate
        //   for physics engines, but is a huge headache for rendering engines.
        // We keep the bullet convention that all heightfields are automatically
        //   recentered, so their local bounding box is symmetric about the
        //   local origin.
        // As a result, we need to calculate the offset.  This is used to
        //   center the heightfield, and is used to account for that centering
        //   when rendering.

        m_offset.x = 0.5 * (m_boundingBox.x0 + m_boundingBox.x1);
        m_offset.y = 0.5 * (m_boundingBox.y0 + m_boundingBox.y1);
        m_offset.z = 0.5 * (m_boundingBox.z0 + m_boundingBox.z1);
        m_offset.dump("Calculated offset");

        m_boundingBox.translate(-m_offset);
        m_boundingBox.dump("Offset bounding box");

        // also, ask heightfield height in middle...
        DPRINTF("Height at (0,0): %lf", hfield->getHeight(0, 0));
        DPRINTF("Height at (%f, %f): %f", -m_offset.x, -m_offset.z, hfield->getHeight(-m_offset.x, -m_offset.z));

        float yMax = hfield->getMaxHeight() * yScale;
        float yMin = hfield->getMinHeight() * yScale;
        float yAvg = 0.5 * (yMax + yMin);
        DPRINTF("y-value at center: %f", yAvg);
        m_yOffset = -yAvg;

        // all done!
        glPopMatrix();
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, iOldMode);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iOldMinFilter);

        // any OpenGL state changes?
//      smart_ptr<glut::State> state2 = glut::State::snapshotFromOpenGL();
//      state->diff(state2);
}



void
Terrain::render
(
IN const render_context_t& rc,
IN RenderQueue * rq
)
{
        perf::Timer timer("Terrain::render");
        ASSERT(rq, "null");
        ASSERT(m_tileset, "null");
        ASSERT(m_cache, "null");

        // TODO: handle rotations!
        // Although I'm not sure how important that is.  Most people don't
        //   rotate heightfields.

        // get orientation
        point3d_t view = rc.viewer.getFacing();
        point3d_t eye = rc.viewer.getPosition();
        point3d_t up = rc.viewer.getUp();

        // libmini assumes you are rendering at the origin.  We need to
        //   compensate for where the heighfield is actually centered,
        //   and our local centering offset.
        glPushMatrix();

        // adjust for our bounding box offset and actual position
//      eye = eye + m_offset;
        eye = eye - rc.placement.position;
        eye.y = eye.y - m_yOffset;

        static int s_counter = 0;
        if (!(s_counter % 1000)) {
                DPRINTF("Rendering heightfield!");
                rc.viewer.getPosition().dump("  viewer");
                rc.placement.position.dump("  placement");
                eye.dump("  eye");
                m_offset.dump("  offset");
                DPRINTF("  y-offset: %f", m_yOffset);
        }
        ++s_counter;

        Viewer local = rc.viewer;
        local.setPosition(eye);
        setOpenGLViewer(local);

        // set normal
        // TODO: libmini should handle normals as part of terrain!
//      glNormal3f(0.0, 1.0, 0.0);
//      glBindTexture(GL_TEXTURE_2D, 0);

        // cache parameters
        float resolution = 400.0;       // high numbers=more resolution--and CPU
        int updates = 5;                // draws per cache update

        // save the current texture environment mode
        // (libmini sometimes changes it!)
        int iTexMode;
        glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &iTexMode);
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

        // enable color materials
        int oldColorMaterial;
        glGetIntegerv(GL_COLOR_MATERIAL, &oldColorMaterial);
        glEnable(GL_COLOR_MATERIAL);

        // save texture minfilter, since libmini messes with this
        int oldTexMinFilter;
        glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
            &oldTexMinFilter);

        // save ambient and diffuse materials, since libmini messes with these
        float oldAmbient[4];
        float oldDiffuse[4];
        glGetMaterialfv(GL_FRONT, GL_AMBIENT, oldAmbient);
        glGetMaterialfv(GL_FRONT, GL_DIFFUSE, oldDiffuse);

        // dump openGL state
//      smart_ptr<glut::State> state = glut::State::snapshotFromOpenGL();
//      ASSERT(state, "null");
//      state->dump("state");

        // let cache know we are using it
        m_cache->makecurrent();

        // set up cache
        {
                perf::Timer timer("minitile::draw");
                m_tileset->draw(resolution,
                                eye.x, eye.y, eye.z,
                                view.x, view.y, view.z,
                                up.x, up.y, up.z,
                                rc.camera.getFovy(),
                                rc.camera.getAspect(),
                                rc.camera.getZNear(),
                                rc.camera.getZFar(),
                                updates);
        }

        // actually draw
        {
                perf::Timer timer("minicache::draw");
                m_cache->rendercache();
        }

//      smart_ptr<glut::State> state2 = glut::State::snapshotFromOpenGL();
//      state->diff(state2);

        // restore texture environment mode
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, iTexMode);
        if (!oldColorMaterial) {
                glDisable(GL_COLOR_MATERIAL);
        }

        // restore texture min filter
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, oldTexMinFilter);

        // restore color materials
        glMaterialfv(GL_FRONT, GL_AMBIENT, oldAmbient);
        glMaterialfv(GL_FRONT, GL_DIFFUSE, oldDiffuse);

        // put matrices back
        glPopMatrix();
}



class LoadTerrain : public Task {
public:
        LoadTerrain(IN Terrain * terrain, IN hfield::Heightfield * hfield) {
                        ASSERT(terrain, "null");
                        ASSERT(hfield, "null");
                        m_terrain = terrain;
                        m_hfield = hfield;
                }
        void doTask(void) {
                        ASSERT(m_terrain, "null");
                        ASSERT(m_hfield, "null");
                        m_terrain->initialize(m_hfield);
                }

private:
        Terrain *               m_terrain;
        hfield::Heightfield *   m_hfield;
};


////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Renderable>
createTerrain
(
IN hfield::Heightfield * hfield
)
{
        ASSERT(hfield, "null");

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

        // we have to delegate to GLUT for the actual load, since the
        // libmini library makes a bunch of glut calls
        LoadTerrain task(local, hfield);
        requestTask(&task);
        return local;
}



};      // glut namespace