heightfield.cpp

Go to the documentation of this file.

/*
 * heightfield.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.
 *
 *
 * Implementation of a basic heightfield object.
 * See heightfield.h
 */

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

#include "common/wave_ex.h"

#include "datahash/datahash_util.h"
#include "pgmppm/pgmppm.h"
#include "nstream/nstream.h"
#include "util/file.h"
#include "util/token_stream.h"


namespace hfield {


// interface destructor implementation
Heightfield::~Heightfield(void) throw() { }


typedef std::vector<short> vec_short_t;


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

class HField : public Heightfield {
public:
        ~HField(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IO nstream::Stream * stream);

        // hfield::Heightfield class interface methods -------------------------
        void dump(IN const char * txt) const throw();
        int getWidth(void) const throw() { return m_width; }
        int getLength(void) const throw() { return m_length; }
        float getXZScale(void) const throw() { return m_xzScale; }
        float getYScale(void) const throw() { return m_yScale; }
        short getMinHeight(void) const throw() { return m_minHeight; }
        short getMaxHeight(void) const throw() { return m_maxHeight; }
        const short * getHeightArray(void) const throw() { return &m_hfield[0]; }
        smart_ptr<nstream::Manager> getStreamManager(void) throw() { return m_mgr; }
        const char * getHeightfieldPath(void) const throw();
        const char * getTexturePath(void) const throw();
        float getHeight(IN float x, IN float z) const throw();

private:
        // private helper methods ----------------------------------------------
        static bool notifySize(IN void * context,
                                IN int width,
                                IN int length,
                                IN int max_val);
        static void writePixel(IN void * context,
                                IN int x,
                                IN int y,
                                IN int height);
        float getRawHeight(IN int gridX,
                                IN int gridZ) const throw();

        // private data members ------------------------------------------------
        int                     m_width;
        int                     m_length;
        float                   m_yScale;       // height increments
        float                   m_xzScale;      // grid point spacing
        long                    m_nPoints;      // # points in grid (w * h)
        short                   m_minHeight;
        short                   m_maxHeight;
        std::string             m_heightfieldFile;
        std::string             m_textureFile;
        smart_ptr<nstream::Manager> m_mgr;
        vec_short_t             m_hfield;       // points (16-bit resolution)
};



void
HField::initialize
(
IO nstream::Stream * pstream
)
{
        ASSERT(pstream, "null");
        ASSERT(pstream->good(), "bad?");

        std::istream& stream = pstream->getStream();

        // get the manager
        smart_ptr<nstream::File> file = pstream->getFile();
        ASSERT_THROW(file, "stream has no file?");
        m_mgr = file->getManager();
        ASSERT_THROW(m_mgr, "stream has no manager?");

        // first token should be version tag!
        expectToken(stream, "hfieldVersion");
        expectToken(stream, "0.1");

        // next token should be the heightfield definition
        expectToken(stream, "heightfield");

        // should see an opening bracket
        expectToken(stream, "{");
        std::string token;

        // load the heightfield data
        expectToken(stream, "yScale");
        m_yScale = readFloat(stream, token);
        ASSERT(m_yScale > 0.0, "Bad y-scale: %f", m_yScale);

        expectToken(stream, "xzScale");
        m_xzScale = readFloat(stream, token);
        ASSERT(m_xzScale > 0.0, "Bad xz-scale: %f", m_xzScale);

        // read heightfield data from PGM file
        expectToken(stream, "hfieldFile");
        getNextToken(stream, token);
        const char * filename = token.c_str();
        const char * ext = GetExtension(filename);
        if (!ext || strcmp("pgm", ext)) {
                WAVE_EX(wex);
                wex << "Invalid heightfield filename: " << filename;
        }

        // get stream for the PGM file, relative to this stream
        smart_ptr<nstream::Stream> pgmStream =
            nstream::getStreamRelativeTo(pstream, filename);
        ASSERT_THROW(pgmStream, "Cannot open heightfield PGM: " << filename);

        // read PGM file
        std::istream& infile = pgmStream->getStream();
        if (!pgmppm::readPgm(infile, notifySize, writePixel, this)) {
                WAVE_EX(wex);
                wex << "Error reading PGM file: ";
                wex << filename;
        }

        // save heighfield path
        m_heightfieldFile = nstream::getStreamName(pgmStream);

        // note but do not read the texture file
        expectToken(stream, "textureFile");
        getNextToken(stream, token);
        m_textureFile =
            getPathRelativeTo(m_heightfieldFile.c_str(), token.c_str());

        // all done!
        expectToken(stream, "}");
}



bool
HField::notifySize
(
IN void * ctx,
IN int width,
IN int length,
IN int max_val
)
{
        HField * pThis = (HField *) ctx;
        ASSERT(pThis, "null context");
        ASSERT(width > 0, "Bad width: %d", width);
        ASSERT(length > 0, "Bad length: %d", length);
        ASSERT(max_val > 0, "bad max_val: %d", max_val);

        pThis->m_width = width;
        pThis->m_length = length;
        pThis->m_nPoints = width * length;

        pThis->m_hfield.clear();
        pThis->m_hfield.resize(pThis->m_nPoints);

        return true;
}



void
HField::writePixel
(
IN void * ctx,
IN int x,
IN int y,
IN int height
)
{
        HField * pThis = (HField *) ctx;
        ASSERT(pThis, "null context");
        ASSERT(x >= 0 && x < pThis->m_width, "Bad x: %d", x);
        ASSERT(y >= 0 && y < pThis->m_length, "Bad y: %d", y);

        short s = (short) height;

        if (!x && !y) {
                pThis->m_minHeight = s;
                pThis->m_maxHeight = s;
        } else {
                if (s < pThis->m_minHeight) {
                        pThis->m_minHeight = s;
                }
                if (s > pThis->m_maxHeight) {
                        pThis->m_maxHeight = s;
                }
        }

        int idx = (y * pThis->m_width) + x;

        pThis->m_hfield[idx] = s;
}



void
HField::dump
(
IN const char * txt
)
const
throw()
{
        DPRINTF("Heightfield: %s", txt);
        DPRINTF("  heightfieldFile: %s", m_heightfieldFile.c_str());
        DPRINTF("  textureFile:     %s", m_textureFile.c_str());
        DPRINTF("  width (x grid extent):  %d", m_width);
        DPRINTF("  length (z grid extent): %d", m_length);
        DPRINTF("  yScale: %f", m_yScale);
        DPRINTF("  xzScale: %f", m_xzScale);
        DPRINTF("  minHeight: %d", m_minHeight);
        DPRINTF("  maxHeight: %d", m_maxHeight);
        DPRINTF("  Derived width (x):  %f", m_xzScale * (m_width - 1));
        DPRINTF("  Derived length (z): %f", m_xzScale * (m_length - 1));
        DPRINTF("  Derived min Y: %f", m_yScale * m_minHeight);
        DPRINTF("  Derived max Y: %f", m_yScale * m_maxHeight);
}



const char *
HField::getHeightfieldPath
(
void
)
const
throw()
{
        return m_heightfieldFile.c_str();
}



const char *
HField::getTexturePath
(
void
)
const
throw()
{
        return m_textureFile.c_str();
}



float
HField::getHeight
(
IN float x,
IN float z
)
const
throw()
{
        ASSERT(m_xzScale > 0, "Bad xz-scale: %f", m_xzScale);

        float fX = x / m_xzScale;
        float fZ = z / m_xzScale;

        int iX = (int) fX;
        int iZ = (int) fZ;

        if (x < 0)
                iX -= 1;
        if (z < 0)
                iZ -= 1;

        float qX = fX - iX;
        float qZ = fZ - iZ;

        ASSERT(qX >= 0.0 && qX <= 1.0, "Bad qX: %f", qX);
        ASSERT(qZ >= 0.0 && qZ <= 1.0, "Bad qZ: %f", qZ);

        qX = 1.0 - qX;
        qZ = 1.0 - qZ;

/*
        DPRINTF("x,z = (%f, %f)", x, z);
        DPRINTF("  iX=%d   fX=%f   qX=%f", iX, fX, qX);
        DPRINTF("  iZ=%d   fZ=%f   qZ=%f", iZ, fZ, qZ);
        exit(0);
 */

        float total = 0.0;
        total += qX * qZ * this->getRawHeight(iX, iZ);
        total += qX * (1.0 - qZ) * this->getRawHeight(iX, iZ + 1);
        total += (1.0 - qX) * qZ * this->getRawHeight(iX + 1, iZ);
        total += (1.0 - qX) * (1.0 - qZ) * this->getRawHeight(iX + 1, iZ + 1);

        return total * m_yScale;
}


float
HField::getRawHeight
(
IN int gridX,
IN int gridZ
)
const
throw()
{
        if (gridX < 0)
                gridX = 0;
        if (gridX >= m_width)
                gridX = m_width - 1;

        if (gridZ < 0)
                gridZ = 0;
        if (gridZ >= m_length)
                gridZ = m_length - 1;

        const short * p = this->getHeightArray();
        ASSERT(p, "null");

        return *(p + gridX + m_width * gridZ);  
}



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

smart_ptr<Heightfield>
Heightfield::create
(
IN nstream::Stream * stream
)
{
        ASSERT(stream, "null");
        ASSERT(stream->good(), "bad?");

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

        local->initialize(stream);

        return local;
}



};      // hfield namespace