demoConfig/main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2010,2011  Thomas A. Vaughan
 * All rights reserved.
 *
 * Simple program to demonstrate the gamepad configuration conversations.
 */

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

#include "conversation/conversation.h"
#include "datahash/datahash_text.h"
#include "dialog/dialog.h"
#include "dialog-draw/dialog-draw.h"
#include "gamepad-config-dialog/gamepad-config-dialog.h"
#include "gamepad-vgfx-element/gamepad-vgfx-element.h"
#include "glut-demo/glut-demo.h"
#include "glut-font/glut-font.h"
#include "opengl-effects/opengl-effects.h"
#include "perf/perf.h"
#include "restream/restream.h"
#include "util/file.h"
#include "vgfx-opengl-draw/vgfx-opengl-draw.h"
#include "wave-glut/texture.h"


// resources (namespace / name)
static const char * s_resourceFont      = "demoConfig/gravitat.ttf";
static const char * s_resourceMap       = "demoConfig/nasa-mars-map.png";

static const float s_fontPointSize      = 24.0;

static const char * s_dialogId          = "gamepadConfig";

static const float s_degreesPerSecond   = 30.0;


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

class Host : public glut::DemoHost, public converse::ConversationRouter,
                public dialog::Host {
public:
        // constructor, destructor ---------------------------------------------
        ~Host(void) throw() { }

        // public class methods ------------------------------------------------

        // glut::DemoHost class interface methods ------------------------------

        bool displayAxes(void) { return false; }
        bool displayQueuedPolys(void) { return false; }

        void onInit(void) {
                        ASSERT(m_dataDir, "null");
                        m_counter = 0;

                        // get access to our built-in resources
                        smart_ptr<nstream::Manager> mgr =
                            nstream::getResourceStreamManager();
                        ASSERT_THROW(mgr, "failed to create resource stream");

                        // load the font
                        m_fontMgr = glut::FontManager::create();
                        ASSERT_THROW(m_fontMgr, "null");

                        smart_ptr<nstream::Stream> stream =
                            nstream::openNamedStream(mgr, s_resourceFont);

                        // create OpenGL dialog drawer
                        dialog::ogl_dialog_draw_t odd;
                        odd.font = m_fontMgr->getFont(stream);
                        ASSERT_THROW(odd.font,
                            "Failed to load font from resources");
                        odd.font->setFaceSize(s_fontPointSize);
                        smart_ptr<dialog::Drawer> drawer =
                            dialog::createOpenGLDrawer(odd);
                        ASSERT_THROW(drawer, "failed to create OpenGL drawer");

                        // create OpenGL vgfx drawer
                        smart_ptr<vgfx::Drawer> vgfxDrawer =
                            vgfx::createOpenGLDrawer();
                        ASSERT_THROW(vgfxDrawer,
                            "failed to create OpenGL vgfx drawer");

                        // create the gamepad manager
                        m_gamepadMgr = gamepad::Manager::create(m_dataDir);
                        ASSERT_THROW(m_gamepadMgr, "failed to create");

                        // create our local dialog manager
                        smart_ptr<crypto::DESKey> nullKey;
                        m_dialogMgr = dialog::Manager::create(nullKey, drawer);
                        ASSERT_THROW(m_dialogMgr, "failed to create");

                        // register the TestElement factory
                        gamepad::registerVgfxTestFactory(m_gamepadMgr,
                            m_dialogMgr, vgfxDrawer);

                        // register the SimpleElement factory
                        gamepad::registerVgfxSimpleFactory(m_gamepadMgr,
                            m_dialogMgr, vgfxDrawer);

                        // create the conversation manager
                        m_converseMgr =
                            converse::ConversationManager::create(this);
                        ASSERT_THROW(m_converseMgr, "failed to create");

                        // kick off the dialog
                        m_x = 100;
                        m_y = 100;
                        this->startDialog();

                        // load the map
                        media::image_t img;
                        ASSERT_THROW(media::loadImage(mgr, s_resourceMap, img),
                            "Failed to load file: " << s_resourceMap);

                        // create texture-mapped sphere
                        glut::tex_sphere_t ts;
                        ts.radius = 3.0;
                        ts.textureId = glut::createTextureFromImage(img);

                        m_sphere = glut::createMappedSphere(ts);
                        ASSERT(m_sphere, "null");

                        m_angle = 0.0;
                }

        void onIdle(IN float dt) {
                        m_angle += s_degreesPerSecond * dt;
                }

        void display3D(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq) {
                        ASSERT(rq, "null");

                        glTranslatef(0, 0, 5);
                        glRotatef(-33, 1, 0, 0);

                        // draw planet...
                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();

                        glRotatef(m_angle, 0, 1, 0);

                        m_sphere->render(rc, rq);

                        glPopMatrix();

                        // draw spheres
                        glColor3f(0.5, 0.5, 0.5);
                        for (int i = 0; i < 3; ++i) {
                                glPushMatrix();

                                float sign = pow(-1.0f, i);
                                glRotatef(m_angle * (3 - i) * sign, 0, 1, 0);
                                glTranslatef(0, 0, (i * 1.5) + 4.5);
                                glRotatef(m_angle * 2.5 * sign, 0, 1, 0);
                                glutSolidSphere(0.25, 6, 6);

                                glPopMatrix();
                        }
                }

        void display2D(int width, int height) {
                        ++m_counter;
                        if (0 == (m_counter % 128)) {
                                if (m_gamepadMgr->rediscover()) {
                                        gamepad::autoconfigureGamepads(m_gamepadMgr);
                                }
                        }
                        m_gamepadMgr->update(); // re-poll all button state
                        m_converseMgr->updateAll();
                        m_dialogMgr->display(width, height);
                }

        void onButton(IN int button, IN int state, IN int x, IN int y) {
                        // intercept all mouse clicks
                        if (!m_dialogMgr->doesDialogExist(s_dialogId)) {
                                // no dialog?  if this is a click down, start
                                if (state) {
                                        m_x = x;
                                        m_y = y;
                                        this->startDialog();
                                }
                                return;
                        }
                        m_dialogMgr->button(button, state, x, y);
                }

        void onCursor(IN int x, IN int y) {
                        m_dialogMgr->cursor(x, y);
                }

        // converse::ConversationRouter class interface methods ----------------
        void routeConversationTS(IN const char * guid,
                                IN int dialogId,
                                IN int playerId,
                                IN converse::conn_id_t connId,
                                IN const char * dialogData) {
                        //DPRINTF("Asked to render dialog '%s'", guid);

                        // convert dialog text to hash
                        smart_ptr<Datahash> hash =
                            readHashFromString(dialogData);
                        ASSERT_THROW(hash, "failed to read hash from string");

                        // remember dialog ID etc
                        m_guid = guid;
                        m_dialogId = dialogId;
                        m_connId = connId;
                        m_playerId = playerId;

                        // for now, dumb routing: display everything here!
                        ASSERT(m_dialogMgr, "null");
                        if (dialogId) {
                                m_dialogMgr->createDialog(guid, m_x, m_y, hash, this);
                        } else {
                                m_dialogMgr->destroyDialog(guid);
                        }
                }

        // dialog::Host class interface methods --------------------------------
        void notifySubmit(IN const char * guid, IN const Datahash * reply) {
                        DPRINTF("Received submit for dialog: %s", guid);
                        ASSERT(reply, "null");

                        // forward to conversation host
                        m_converseMgr->handleDialogReplyTS(guid, m_dialogId,
                            m_connId, m_playerId, reply);
                }

        // static factory method -----------------------------------------------
        static smart_ptr<Host> create(IN const char * dataDir,
                                        IN const char * imageDir) {
                        ASSERT(dataDir, "null");
                        ASSERT(imageDir, "null");

                        smart_ptr<nstream::Manager> fsMgr =
                            nstream::getFilesystemManager(dataDir);
                        ASSERT_THROW(fsMgr,
                            "Failed to create filesystem manager for data dir: "
                            << dataDir);

                        smart_ptr<Host> local = new Host;
                        ASSERT(local, "out of memory");
                        local->m_dataDir = fsMgr->getRoot();
                        local->m_imageDir = imageDir;

                        return local;
                }

private:
        // private methods -----------------------------------------------------
        Host(void) throw() { }

        void startDialog(void) {
                        ASSERT(m_gamepadMgr, "null");
                        ASSERT(m_converseMgr, "null");

                        // create the gamepad config conversation host
                        smart_ptr<converse::ConversationHost> host =
                            gamepad::createConfigurationHost(m_gamepadMgr);
                        ASSERT(host, "failed to create");

                        // request conversation
                        m_converseMgr->updateConversationTS(s_dialogId,
                            1, 1, host);
                }

        // private member data -------------------------------------------------
        smart_ptr<converse::ConversationManager>        m_converseMgr;
        smart_ptr<gamepad::Manager>                     m_gamepadMgr;
        smart_ptr<dialog::Manager>                      m_dialogMgr;
        smart_ptr<nstream::Folder>                      m_dataDir;
        smart_ptr<glut::Renderable>                     m_sphere;
        smart_ptr<glut::FontManager>                    m_fontMgr;
        const char *                                    m_guid;
        std::string                                     m_imageDir;
        int                                             m_dialogId;
        converse::conn_id_t                             m_connId;
        int                                             m_playerId;
        int                                             m_counter;
        int                                             m_x;
        int                                             m_y;
        float                                           m_angle;
};


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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        ASSERT(2 == argc, "Usage: demoConfig <data-directory>");
        const char * dataDir = argv[1];
        DPRINTF("Using data directory: '%s'", dataDir);

        try {

                // get this directory
                const char * exePath = argv[0];
                DPRINTF("Executable: %s", exePath);
                std::string parentDir;
                GetParentDirectory(exePath, parentDir);

                const char * title = "Gamepad Configuration Demo";

                smart_ptr<glut::DemoHost> host =
                    Host::create(dataDir, parentDir.c_str());
                ASSERT(host, "failed to create demo host");

                glut::startDemo(argc, argv, title, host);

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

        perf::dumpTimingSummary(std::cerr);

        return retval;
}