test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Quick test for the map-kdtree library.
 */

// includes --------------------------------------------------------------------
#include "datahash/datahash_text.h"
#include "glut-demo/glut-demo.h"
#include "map-kdtree/map-kdtree.h"
#include "mapzone/mapzone.h"
#include "model-loader/model-loader.h"
#include "perf/perf.h"
#include "physics-loader/physics-loader.h"


static const char * s_bogusPhysicsParameters = 
        "physics {\n"
        "    minCoord       -10000\n"
        "    maxCoord       +10000\n"
        "    maxTimeSteps        5\n"
        "    engineTimeStep   0.02\n"
        "    gravityAxis         1\n"
        "    gravity          -9.8\n"
        "}\n";


static aesop::map_draw_stats_t s_stats;


//
//      static helper methods
//

static void
drawZone
(
IN aesop::Zone * zone,
IN void * context
)
{
        ASSERT(zone, "null");
        // ASSERT(context) -- not used

        // determine color based on zone type
        glut_color_t c;
        float val = 1.0;
        float a2 = 0.5;
        float deflate = 0;
        switch (zone->getType()) {
        case aesop::Zone::eType_Parent:
                c.set(  0, val,   0,  a2);
                deflate = 0.25;
                break;
        case aesop::Zone::eType_Leaf:
                c.set(  0,   0, val,  a2);
                deflate = 0.5;
                break;
        case aesop::Zone::eType_VirtualLeaf:
                c.set( a2,   0,  a2,  a2);
                deflate = 0.5;
                break;
        default:
                ASSERT(false, "Bad zone type?");
        }

        rect3d_t r;
        zone->getBoundingRect(r);
        r.inflate(-deflate);

        glut::drawRectLines(r, c);
}



static void
drawNode
(
IN const aesop::kd_node_t& kn,
IN void * context
)
{
        // ASSERT(context) -- not used

        glut_color_t c(1.0, 1.0, 0, 0.5);
//      kn.rect.dump("Node rect");
        rect3d_t r = kn.rect;
        r.inflate(-0.01 * kn.depth);

        glut::drawRectLines(r, c);
}



//
//      Drawer -- class that implements the glut::DemoHost interface
//

class Drawer : public glut::DemoHost {
public:
        Drawer(IN const char * mapId, IN const char * storyDir) :
            m_mapId(mapId), m_storyDir(storyDir) { }
        ~Drawer(void) throw() { }

        // glut::DemoHost class interface methods ------------------------------
        float getDelta(void) { return 0.1; }

        void onInit(void) {
                perf::Timer timer("initializing");

                const char * mapId = m_mapId.c_str();
                const char * storyDir = m_storyDir.c_str();

                // locale
                const char * locale = i18n::getHostLocale();
                if (!locale) {
                        locale = "en_US.UTF-8";
                }
                DPRINTF("Using locale = '%s'", locale);

                // load story
                smart_ptr<story::Story> story =
                    story::Story::create(locale, storyDir);
                ASSERT_THROW(story, "failed to create story database");

                // initialize typeinst library
                aesop::initializeTypeInstanceLibrary(story);

                // get 3D model loader
                smart_ptr<aesop::TypeComponentLoader> modelLoader =
                    aesop::createModelLoader(story);
                ASSERT_THROW(modelLoader, "failed to create 3D model loader");
                aesop::registerTypeComponentLoader(modelLoader);

                // get map path
                std::string path = story->getObjectPath("map", mapId);
                DPRINTF("Map id: '%s'", mapId);
                DPRINTF("  --> path: %s", path.c_str());

                // register the default mapzone loader
                smart_ptr<aesop::MapFormatReader> reader =
                    mapzone::getMapFormatReader();
                ASSERT_THROW(reader, "failed to acquire mapzone format reader");
                registerMapFormatReader(reader);

                // load map
                smart_ptr<aesop::Map> map = aesop::loadMap(mapId, path.c_str());
                ASSERT_THROW(map, "failed to load map");

                // create a datahash with bogus physics parameters
                std::istringstream iss(s_bogusPhysicsParameters);
                smart_ptr<Datahash> params = readHashFromStream("root", iss);
                ASSERT_THROW(params, "failed to create empty datahash");

                // load map dynamics
                m_dynamics = aesop::MapDynamics::create(map, params);
                ASSERT_THROW(m_dynamics, "failed to create map dynamics");

                // create map kdtree
                m_kdTree = aesop::MapKdTree::create(m_dynamics);
                ASSERT_THROW(m_kdTree, "failed to create map kdtree");
                }

        void display3D(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq) {
                        ASSERT(m_dynamics, "null");
                        ASSERT(m_kdTree, "null");
                        //DPRINTF("Drawing!");

                        // render all objects
                        aesop::drawMap(m_kdTree, rc, rq, s_stats);

                        // draw all zones
                        aesop::Map * map = m_dynamics->getMap();
                        ASSERT(map, "null");

                        map->iterateZones(drawZone, NULL);

                        // draw kd tree
                        m_kdTree->walkNodes(drawNode, NULL);
                }

private:
        // private member data -------------------------------------------------
        std::string                     m_mapId;
        std::string                     m_storyDir;
        smart_ptr<aesop::MapKdTree>     m_kdTree;
        smart_ptr<aesop::MapDynamics>   m_dynamics;
};



//
//      entry point
//

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        ASSERT(3 == argc,
            "Usage: map-kdtree-test <story-dir> <map-id>");
        const char * storyDir = argv[1];
        const char * mapId = argv[2];

        try {
                // construct title
                char title[1024];
                sprintf(title, "MapKdTree test [map '%s' in story '%s']",
                    mapId, storyDir);

                // main loop
                smart_ptr<glut::DemoHost> host = new Drawer(mapId, storyDir);
                ASSERT(host, "null");
                glut::startDemo(argc, argv, title, host);
        } catch (std::exception& e) {
                retval = 1;
                DPRINTF("Exception: %s", e.what());
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}