genBuilding/main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Quick program to autogenerate multi-zone buildings.
 */

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

#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "geometry/geometry_3d.h"
#include "geometry/matrix_4.h"
#include "perf/perf.h"



static const float s_radiansPerDegree           = M_PI / 180.0;


// an axis determines a chain of rooms, with winding factors etc
struct axis_t {
        // constructor, manipulators
        axis_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        windAngle.clear();
                        windStep.clear();
                        run = 0;
                }

        // data fields
        point3d_t       windAngle;
        point3d_t       windStep;
        int             run;
};


typedef std::map<std::string, smart_ptr<axis_t> > axis_map_t;


// this is the overall state of the building (or cluster thereof)
struct state_t {
        // constructor, manipulators
        axis_t * getAxis(IN const char * name) {
                        ASSERT(name, "null");
                        axis_map_t::iterator i = axisMap.find(name);
                        ASSERT_THROW(axisMap.end() != i,
                            "No such axis: '" << name << "'");
                        ASSERT(i->second, "null axis in map?");
                        return i->second;
                }

        // data fields
        axis_map_t      axisMap;
};



//
//      static helper methods
//

static smart_ptr<axis_t>
parseAxis
(
IN const Datahash * hash
)
{
        smart_ptr<axis_t> axis = new axis_t;
        ASSERT(axis, "out of memory");

        axis->run = getInt(hash, "run");

        // get axis winding parameters
        smart_ptr<Datahash> wind = getSubhash(hash, "winding");
        ASSERT(wind, "null");

        const char * rot = getOptionalString(wind, "rot", "");
        const char * step = getOptionalString(wind, "step", "");

        point3d_t rotateDegrees;
        parsePoint3d(rot, rotateDegrees);
        axis->windAngle = s_radiansPerDegree * rotateDegrees;
        parsePoint3d(step, axis->windStep);

        return axis;
}



static void
getAxisRegistry
(
IN axis_map_t& map,
IN const Datahash * input
)
{
        ASSERT(input, "null");
        map.clear();

        Datahash::iterator_t i;
        input->getIterator("axis", i);
        while (const hash_value_t * phv = input->getNextElementUnsafe(i)) {
                if (!phv->hash)
                        continue;       // skip this one
        
                smart_ptr<axis_t> axis = parseAxis(phv->hash);
                if (axis) {
                        const char * name = getString(phv->hash, "name");
                        ASSERT_THROW(map.end() == map.find(name),
                            "Multiple axes with same name: '" << name << "'");
                        map[name] = axis;
                }
        }
        DPRINTF("Parsed %d axes", map.size());
}



static void
updateTransformation
(
IN const matrix4_t& rootT,
IN const axis_t * axis,
OUT matrix4_t& T
)
{
        ASSERT(axis, "null");

        // first, apply rotation
        matrix4_t rot;
        rot.setYRotation(axis->windAngle.y);

        // next, apply translation
        matrix4_t trans;
        trans.setTranslation(axis->windStep);

        matrix4_t next;
        next.setToProductOf(rot, trans);

        T.setToProductOf(rootT, next);
}



static void
generateRooms
(
IN state_t& state,
IN const matrix4_t& rootT,
IN const axis_t * axis,
IN int count
)
{
        ASSERT(axis, "null");
        ASSERT(axis->run >= 0, "bad run?");
        ASSERT(count >= 0, "invalid room count: %d", count);

        // recursive routine!
        if (count >= axis->run)
                return;         // end of recursion

        // apply transformation
        matrix4_t T;
        updateTransformation(rootT, axis, T);

        // position of next room
        point3d_t p(0, 0, 0);
        point3d_t q = T * p;

        DPRINTF("Room %d:", count);
        q.dump("  position");

        // recurse
        generateRooms(state, T, axis, count + 1);
}



static void
genBuilding
(
IN const Datahash * input
)
{
        ASSERT(input, "null");

        state_t state;

        // get registry of axes
        getAxisRegistry(state.axisMap, input);

        // what is the root axis name?
        const char * rootName = getString(input, "rootAxis");
        DPRINTF("Root axis name: '%s'", rootName);

        axis_t * axis = state.getAxis(rootName);
        ASSERT(axis, "null root axis");

        // first, generate rooms
        matrix4_t T;
        T.setIdentity();
        {
                perf::Timer timer("room-generation");
                generateRooms(state, T, axis, 0);
        }
}



//
//      entry point
//

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        ASSERT(2 == argc,
            "usage: genBuilding <input-file>");
        const char * infile = argv[1];
        DPRINTF("Using input file: '%s'", infile);

        try {
                perf::Timer timer("overall timer");

                smart_ptr<Datahash> input = readHashFromTextFile(infile);
                ASSERT(input, "null");

                genBuilding(input);

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

        perf::dumpTimingSummary(std::cerr);

        return retval;
}