aesop-core/tool/terrain/terraTextureGen/main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2009,2010  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.
 *
 */

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

#include "common/wave_ex.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "hfield/heightfield.h"
#include "perf/perf.h"
#include "pgmppm/pgmppm.h"              // PGM/PPM files
#include "util/date.h"
#include "util/file.h"


// statics and typedefs --------------------------------------------------------
typedef pgmppm::color_t color_t;


typedef std::map<float, color_t> map_colors_t;



// contains data concerning the texture we'll be writing
struct texture_t {
        // constructor, manipulators
        texture_t(void) throw() : texture(NULL) { this->clear(); }
        ~texture_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        hfield = NULL;
                        texelsPerGrid = 0;
                        xTexels = zTexels = 0;
                        if (texture) {
                                delete[] texture;
                                texture = NULL;
                        }
                        colors.clear();
                }

        void allocate(void) {
                        ASSERT(!texture, "already allocated?");
                        ASSERT(hfield, "null");
                        ASSERT(texelsPerGrid > 0, "bad");
                        int x = hfield->getWidth();
                        int z = hfield->getLength();
                        xTexels = (x - 1) * texelsPerGrid;
                        zTexels = (z - 1) * texelsPerGrid;

                        DPRINTF("Texture will be %dx%d", xTexels, zTexels);

                        nTexels = xTexels * zTexels;
                        DPRINTF("  %d texels total", nTexels);

                        texture = new color_t[nTexels];
                        ASSERT_THROW(texture, "out of memory");
                }

        color_t& getColor(IN int x, IN int z) const throw() {
                        ASSERT(x >= 0 && x < xTexels, "bad x: %d", x);
                        ASSERT(z >= 0 && z < zTexels, "bad z: %d", z);
                        ASSERT(texture, "null");

                        int idx = (z * xTexels) + x;
                        ASSERT(idx >= 0 && idx < nTexels, "bad idx: %d", idx);

                        return texture[idx];
                }

        // data fields
        smart_ptr<hfield::Heightfield> hfield;  // heightfield
        int                     texelsPerGrid;  // texels per grid point
        int                     xTexels;
        int                     zTexels;
        int                     nTexels;        // total
        color_t *               texture;        // texture data
        map_colors_t            colors;
};



////////////////////////////////////////////////////////////////////////////////
///
/// \ingroup terra_tool
/// \defgroup terraTextureGen terraTextureGen - heightmap generation
///
/// Given an input file, this generates a heightmap, from which you can then
/// generate a texure to get a complete terrain object.
///
/// Sample usage:
/// \code
///     % terraTextureGen sample-input.txt sample
/// \endcode
///
/// That will read the file "sample-input.txt" for parameters, and then
/// output two files:
///  - <b>sample.hfield</b> This is the hfield file that the Wavepacket GLUT
///     heightfield library uses.
///  - <b>sample.pgm</b> This is a PGM file containing height values.
///
/// Note that <b>sample.ppm</b> is referred to by the hfield file, but the
/// PPM does not exist!  Use terraTextureGen to create the ppm file from these
/// two input files.
///
////////////////////////////////////////////////////////////////////////////////

static void
verifyColor
(
IN int c,               // actually a color component (blue, red, ...)
IN const char * name
)
{
        ASSERT_THROW(c >= 0 && c<= 255, "Bad color component: " <<
            name << " = " << c);
}



static int
randDelta
(
void
)
throw()
{
        const int s_max = 16;
        const int s_mod = 2 * s_max + 1;
        int r = rand() % s_mod;
        return s_max - r;
}



static void
rComp
(
IO int& i
)
throw()
{
        // rComp: randomize component (for color)
        i += randDelta();
        if (i < 0) {
                i = 0;
        }
        if (i > 255) {
                i = 255;
        }
}



static color_t
randomize
(
IN const color_t& i_c
)
throw()
{
        color_t c = i_c;
        rComp(c.red);
        rComp(c.green);
        rComp(c.blue);
        return c;
}



static color_t
getColorForHeight
(
IN texture_t * t,
IN float y              // relative y: between 0 (min) and 1 (max)
)
{
        ASSERT(t, "null");
        ASSERT(t->hfield, "null");
        ASSERT(y >= 0 && y <= 1, "bad relative y: %f", y);

        //DPRINTF("Checking color for height: %f", y);

        const color_t * pc = NULL;
        for (map_colors_t::const_iterator i = t->colors.begin();
             i != t->colors.end(); ++i) {
                float h = i->first;     // height is here and above
        //      DPRINTF("  comparing vs. height: %f", h);
                if (h > y) {
                        break;
                }
                pc = &i->second;
        }
        if (pc)
                return randomize(*pc);

        // got here?  invalid color value or some such
        color_t bad;
        bad.red = 255;
        bad.green = bad.blue = 0;
        return bad;
}



static void
setBaseTexture
(
IN texture_t * t
)
{
        perf::Timer timer("setBaseTexture");
        ASSERT(t, "null");
        ASSERT(t->hfield, "null");
        ASSERT(t->texelsPerGrid > 0, "bad");
        ASSERT(t->texture, "null");

        float xzScale = t->hfield->getXZScale();
        xzScale *= (1.0 / t->texelsPerGrid);

        short iMin = t->hfield->getMinHeight();
        short iMax = t->hfield->getMaxHeight();

        float yScale = t->hfield->getYScale();

        float yMin = yScale * iMin;
        float yMax = yScale * iMax;
        DPRINTF("yMin,yMax = %f, %f", yMin, yMax);

        float dY = yMax - yMin;
        float invDY = 1;
        if (dY > 0) {
                invDY = 1.0 / dY;
        }
        DPRINTF("dY, 1/dY = %f, %f", dY, invDY);

        color_t * p = t->texture;
        for (int iz = 0; iz < t->zTexels; ++iz) {
                float z = iz * xzScale;
                for (int ix = 0; ix < t->xTexels; ++ix, ++p) {
                        float x = ix * xzScale;
                        float y = t->hfield->getHeight(x, z);
                        float r = (y - yMin) * invDY;
                        //DPRINTF("  y = %f --> r = %f", y, r);
                        *p = getColorForHeight(t, r);
                }
        }
}



static void
addColor
(
IO color_t& sum,
IN texture_t * t,
IN int ix,
IN int iz
)
{
        color_t c = t->getColor(ix, iz);
        sum.red += c.red;
        sum.green += c.green;
        sum.blue += c.blue;
}



static void
divideColor
(
IO color_t& sum,
IN int count
)
{
        ASSERT(count > 0, "BAd count: %d", count);

        sum.red /= count;
        sum.green /= count;
        sum.blue /= count;
}



static void
smooth
(
IN texture_t * t
)
{
        perf::Timer timer("smooth");
        ASSERT(t, "null");
        ASSERT(t->texture, "null");

        color_t * newTexture = new color_t[t->nTexels];
        ASSERT_THROW(newTexture, "out of memory");

        const color_t * p = t->texture;
        color_t * q = newTexture;
        for (int j = 0; j < t->zTexels; ++j) {
                for (int i = 0; i < t->xTexels; ++i, ++p, ++q) {
                        int nAdj = (rand() % 3);                // number adjacent
                        color_t sum = *p;
                        sum.red *= nAdj;
                        sum.green *= nAdj;
                        sum.blue *= nAdj;

                        if (i > 0) {
                                ++nAdj;
                                addColor(sum, t, i - 1, j);
                        } else if (i < t->xTexels - 1) {
                                ++nAdj;
                                addColor(sum, t, i + 1, j);
                        }
                        if (j > 0) {
                                ++nAdj;
                                addColor(sum, t, i, j - 1);
                        } else if (j < t->zTexels - 1) {
                                ++nAdj;
                                addColor(sum, t, i, j + 1);
                        }
                        divideColor(sum, nAdj);

                        *q = sum;
                }
        }

        // swap the old for the new
        color_t * old = t->texture;
        t->texture = newTexture;
        delete[] old;
}



static smart_ptr<texture_t>
createTexture
(
IN smart_ptr<hfield::Heightfield>& hfield,
IN const Datahash * params
)
{
        ASSERT(hfield, "null");
        ASSERT(params, "null");

        hfield->dump("just read");

        smart_ptr<texture_t> t = new texture_t;
        ASSERT_THROW(t, "out of memory");

        t->hfield = hfield;

        // get the parameters we need
        t->texelsPerGrid = getInt(params, "texelsPerGridPoint");
        DPRINTF("Using %d texels per heightfield grid point",
            t->texelsPerGrid);
        ASSERT_THROW(t->texelsPerGrid > 0, "Bad texels per grid point: "
            << t->texelsPerGrid);

        // allocate
        t->allocate();

        // read the color entries
        Datahash::iterator_t i;
        params->getIterator("color", i);
        while (const hash_value_t * phv = params->getNextElementUnsafe(i)) {
                if (!phv->hash)
                        continue;       // skip simple values
                const Datahash * sub = phv->hash;
                ASSERT(sub, "null");

                float height = getFloat(sub, "height");
                ASSERT_THROW(height >= 0 && height <= 1,
                    "bad color height: " << height);

                color_t c;
                c.red = getInt(sub, "red");
                c.green = getInt(sub, "green");
                c.blue = getInt(sub, "blue");

                verifyColor(c.red, "red");
                verifyColor(c.green, "green");
                verifyColor(c.blue, "blue");

                t->colors[height] = c;
        }
        DPRINTF("Read %d color entries", (int) t->colors.size());

        // create base texture
        setBaseTexture(t);

        // run smoothing passes
        int nSmooth = 0;
        if (params->count("smoothCount")) {
                nSmooth = getInt(params, "smoothCount");
        }
        ASSERT_THROW(nSmooth >= 0, "Bad smooth count: " << nSmooth);
        for (int i = 0; i < nSmooth; ++i) {
                smooth(t);
        }

        // all done!
        return t;
}



static color_t
writePixel
(
IN void * context,
IN int x,
IN int z
)
{
        const texture_t * t = (const texture_t *) context;
        ASSERT(t, "null context");

        return t->getColor(x, z);
}



static void
writeTexture
(
IN const texture_t * t,
IN const char * outputFile
)
{
        perf::Timer timer("writeTexture");
        ASSERT(t, "null");
        ASSERT(outputFile, "null");

        std::ofstream output(outputFile);
        ASSERT_THROW(output.good(), "Failed to open file for writing: "
            << outputFile);

        // okay, now write output PPM file
        pgmppm::writePpm(output, t->xTexels, t->zTexels, 255,
            writePixel, (void *) t);
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(3 == argc,
            "usage: terraTextureGen <hfield-file> <texture-param-file>");
        const char * hfieldFile = argv[1];
        const char * paramFile = argv[2];

        // start everything up
        int retval = 0;
        try {
                perf::Timer timer("overall program timer");

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

                // open heightfield
                smart_ptr<nstream::Stream> stream =
                    nstream::openNamedStream(mgr, hfieldFile);
                ASSERT(stream, "null");
                smart_ptr<hfield::Heightfield> hfield =
                    hfield::Heightfield::create(stream);
                ASSERT_THROW(hfield, "Failed to load hfield");

                // open texture parameters
                smart_ptr<Datahash> params = readHashFromTextFile(paramFile);
                ASSERT_THROW(params, "Failed to read texture parameter file: "
                    << paramFile);

                // create and write texture
                smart_ptr<texture_t> texture = createTexture(hfield, params);
                writeTexture(texture, hfield->getTexturePath());
        } catch (std::exception& e) {
                DPRINTF("Exception during startup!");
                DPRINTF("%s", e.what());
                retval = 1;
        } catch (...) {
                DPRINTF("Unknown exception during startup!");
                retval = 2;
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}