terminal.cpp

Go to the documentation of this file.

/*
 * terminal.cpp
 *
 * Copyright (C) 2008-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.
 *
 *
 * Implementation of a aesop terminal.  Manages display in particular.
 */

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

#include <sstream>

#include "datahash/datahash_text.h"
#include "dialog-draw/dialog-draw.h"
#include "gamepad-vgfx-element/gamepad-vgfx-element.h"
#include "geometry/geometry_2d.h"
#include "glut/glut.h"
#include "glut/glut_2d.h"
#include "glut/renderable.h"
#include "glut-font/glut-font.h"
#include "map-kdtree/map-kdtree.h"
#include "model-loader/model-loader.h"
#include "perf/perf.h"
#include "vgfx-opengl-draw/vgfx-opengl-draw.h"


namespace aesop {


// Terminal interface destructor
TerminalHost::~TerminalHost(void) throw() { }
Terminal::~Terminal(void) throw() { }


enum eInputMode {
        eMode_Normal            = 1,            
        eMode_Cursor            = 2,            

        // keep this last
        eMode_Invalid           = 0
};


typedef point2d_t<int>          pointi_t;
typedef point2d_t<float>        pointf_t;


static const float s_turnSpeed          = 2.0;  // radians per second


//
//      static helper methods
//

static float
tweakMouseMotion
(
IN float dx
)
throw()
{
        int ix = +1;
        if (dx < 0) {
                dx = -dx;
                ix = -1;
        }
        return 16.0 * ix * dx * dx;
}



static void
clipCoord
(
IN float& x,
IN int maxX
)
throw()
{
        if (x < 0.0) {
                x = 0.0;
        } else if (x > maxX) {
                x = maxX;
        }
}



static float
getRandomX
(
void
)
throw()
{
        return rand() / (1.0 * RAND_MAX);
}



static float
getPotRatio
(
IN const gamepad::pot_value_t& pv
)
throw()
{
        int delta = pv.maxSeen - pv.minSeen;
        if (delta < 1)
                return 0.5;

        return ((float) pv.value - pv.minSeen) / delta;
}



static float
getJoyAxis
(
IN const gamepad::pot_value_t& rawValue
)
throw()
{
        float dx = 2.0 * (getPotRatio(rawValue) - 0.5);

        // cut out the middle 20%
        int iSign = +1;
        if (dx < 0) {
                dx = -dx;
                iSign = -1;
        }

        const float cutoff = 0.2;
        dx -= cutoff;
        if (dx < 0) {
                return 0;
        }
        const float inverted = 1.0 / (1.0 - cutoff);
        return iSign * dx * inverted;
}


//
//      TermImpl -- class that implements the Terminal interface
//

class TermImpl : public Terminal {
public:
        TermImpl(void) throw();
        ~TermImpl(void) throw() { DPRINTF("Destroying terminal"); }

        // public class methods ------------------------------------------------
        void initialize(IN TerminalHost * host,
                                IN int playerId,
                                IN smart_ptr<glut::RenderQueue>& rq);

        // aesop::Terminal class interface methods -----------------------------
        void setKeys(IN smart_ptr<crypto::DESKey>& desKey,
                                IN smart_ptr<gamepad::Manager>& mgr);
        void input(IN gamepad::Gamepad * gp, IN float dt);
        void mouseMove(IN int x, IN int y);
        void mouseButton(IN int button, IN int state,
                                IN int x, IN int y);
        void keyboard(IN int key, IN int mods);
        void showDialog(IN const char * id,
                                IN const Datahash * dialog,
                                IN dialog::Host * host);
        void destroyDialog(IN const char * id);
        void notifyMap(IN MapKdTree * mapKdTree);
        void notifyInstance(IN smart_ptr<Instance>& instance);

        // view::Host class interface methods ----------------------------------
        void render3D(IN int id, IN const view::render_info_t& ri);
        void render2D(IN int id, IN const view::render_info_t& ri);

private:
        // private member data ------------------------------------------------
        smart_ptr<dialog::Manager>              m_dialogManager;
        smart_ptr<glut::RenderQueue>            m_rQueue;
        smart_ptr<vgfx::Drawer>                 m_vgfxDrawer;
        smart_ptr<glut::Renderable>             m_model;
        smart_ptr<Instance>                     m_instance;
        eInputMode                              m_mode;
        int                                     m_playerId;
        TerminalHost *                          m_host;
//      int                                     m_oldButtons;
        pointf_t                                m_cursor;
        float                                   m_back[3];
        int                                     m_maxX;
        int                                     m_maxY;
        int                                     m_lastX;
        int                                     m_lastY;
        bool                                    m_newMap;
        map_draw_stats_t                        m_stats;
        MapKdTree *                             m_mapKdTree;
        glut::Viewer                            m_viewer;
        glut::fps_t                             m_fps;
};



TermImpl::TermImpl(void)
throw()
{
        DPRINTF("New terminal!");

        //m_oldButtons = 0;
        m_mode = eMode_Normal;
        m_maxX = m_maxY = 1;
        m_mapKdTree = NULL;
        m_newMap = false;

        m_lastX = 64;
        m_lastY = 64;

        // pick a background color
        srand(time(NULL));
        m_back[0] = 0.2 + 0.4 * getRandomX();
        m_back[1] = 0.2 + 0.4 * getRandomX();
        m_back[2] = 0.2 + 0.4 * getRandomX();
}



void
TermImpl::initialize
(
IN TerminalHost * host,
IN int playerId,
IN smart_ptr<glut::RenderQueue>& rq
)
{
        ASSERT(host, "null");
        ASSERT(playerId > 0, "bad player id: %d", playerId);
        ASSERT(rq, "null");

        m_host = host;
        m_playerId = playerId;
        m_rQueue = rq;

        m_vgfxDrawer = vgfx::createOpenGLDrawer();
        ASSERT(m_vgfxDrawer, "null");

        smart_ptr<crypto::DESKey> key = NULL;
        smart_ptr<gamepad::Manager> mgr = NULL;
        this->setKeys(key, mgr);

        m_fps.init(perf::getNow());
}



//
//      TermImpl -- aesop::Terminal class interface methods
//

void
TermImpl::setKeys
(
IN smart_ptr<crypto::DESKey>& desKey,
IN smart_ptr<gamepad::Manager>& gamepadMgr
)
{
        // ASSERT(desKey) -- can be null!
        // ASSERT(gamepadMgr) -- can be null!
        ASSERT(m_vgfxDrawer, "null");

        smart_ptr<dialog::Drawer> drawer = dialog::createOpenGLDrawer();
        ASSERT(drawer, "null");

        m_dialogManager = dialog::Manager::create(desKey, drawer);
        ASSERT(m_dialogManager, "failed to create dialog manager");

        // update with gamepad vgfx drawers
        if (gamepadMgr) {
                gamepad::registerVgfxTestFactory(gamepadMgr, m_dialogManager,
                    m_vgfxDrawer);
                gamepad::registerVgfxSimpleFactory(gamepadMgr, m_dialogManager,
                    m_vgfxDrawer);
        }
}



void
TermImpl::input
(
IN gamepad::Gamepad * gp,
IN float dt
)
{
        // ASSERT(gp) -- can be null!
        ASSERT(dt > 0.0, "Bad time increment: %f", dt);

        // if we have a gamepad, get the type
        gamepad::Type * type = (gp) ? gp->getType() : NULL;
        ASSERT(!gp || type, "gamepad but no type?");

        // toggle modes?
        int iLeftJoy = -1;
        int iRightJoy = -1;
        int iAction1 = -1;
        int iTrigger = -1;
        int iLeftJoyPush = -1;
        if (gp) {
                int iStart2 = type->getLogicalIndex("start2",
                    gamepad::eInput_Button);
                iLeftJoy = type->getLogicalIndex("leftJoy",
                    gamepad::eInput_Joystick);
                iRightJoy = type->getLogicalIndex("rightJoy",
                    gamepad::eInput_Joystick);
                iAction1 = type->getLogicalIndex("action1",
                    gamepad::eInput_Button);
                iTrigger = type->getLogicalIndex("rightTrigger",
                    gamepad::eInput_Button);
                iLeftJoyPush = type->getLogicalIndex("leftJoyPush",
                    gamepad::eInput_Button);
                if (iTrigger < 0) {
                        DPRINTF("Failed to retrieve trigger as button, trying pot...");
//                      iTrigger = type->getLogicalIndex("rightTrigger",
//                          gamepad::eInput_Pot);
//                      if (iTrigger < 0) {
                                DPRINTF("Nope!");
//                      }
                }
                if (iStart2 >= 0) {
                        if (gamepad::eButtonWasReleased & gp->getButton(iStart2)) {
                                m_mode = (eMode_Normal == m_mode) ? eMode_Cursor : eMode_Normal;
                                DPRINTF("Mode = %d", m_mode);
                        }
                }
        }

        // exit cursor mode?
//      if (eMode_Cursor == m_mode && input::eGameButton_Escape & released) {
//              m_mode = eMode_Normal;
//      }

        // new map?  get position now
        if (m_newMap) {
                // new map!  update our position immediately
                m_newMap = false;
                point3d_t newPos;
                point3d_t delta;
                delta.clear();  // don't move at all
                point3d_t euler;
                euler.clear();  // hmmm--get this from start point?
                m_host->requestMove(m_playerId, delta, euler, newPos);
                m_viewer.setPosition(newPos);
        }

        // our requested move
        point3d_t delta;
        delta.clear();          // zero move by default

        // update cursor
        gamepad::joystick_t joyR, joyL;
        if (gp && eMode_Cursor == m_mode) {
                gp->getJoystick(iRightJoy, joyR);

                float dx = getJoyAxis(joyR.x);
                float dy = getJoyAxis(joyR.y);

                dx = tweakMouseMotion(dx);
                dy = tweakMouseMotion(dy);

                m_cursor.x += dx;
                m_cursor.y += dy;

                // clip
                clipCoord(m_cursor.x, m_maxX);
                clipCoord(m_cursor.y, m_maxY);

                int x = (int) m_cursor.x;
                int y = (int) m_cursor.y;

                gamepad::eButton button = gp->getButton(iAction1);

                if (gamepad::eButtonWasPushed & button) {
                        m_dialogManager->button(0, 0, x, y);
                } else if (gamepad::eButtonWasReleased & button) {
                        m_dialogManager->button(0, 1, x, y);
                } else if (gamepad::eButtonDown & button) {
                        m_dialogManager->cursor(x, y);
                }
        } else if (gp) {
                // not in cursor mode--update viewer

                const char * verb = "idle";

                gp->getJoystick(iRightJoy, joyR);
                gp->getJoystick(iLeftJoy, joyL);

                // first, rotations (right gamepad)
                float dx = getJoyAxis(joyR.x);
                float dy = getJoyAxis(joyR.y);

                float rotY = -dx * dt * s_turnSpeed;
                float rotUp = dy * dt * s_turnSpeed;

                m_viewer.rotateY(rotY);
                m_viewer.rotateUp(rotUp);

                // next, motion (left stick on gamepad)
                dx = getJoyAxis(joyL.x);
                float dz = getJoyAxis(joyL.y);
                dy = 0.0;

                ASSERT(dx > -1.01 && dx < 1.01, "bad dx: %f", dx);
                ASSERT(dz > -1.01 && dz < 1.01, "bad dz: %f", dz);

                // is left joystick pressed?
                float mult = 1.0;
                if (iLeftJoyPush >= 0 &&
                    gamepad::eButtonDown & gp->getButton(iLeftJoyPush)) {
                        mult = 4.0;
                        verb = "run";
                } else {
                        float r = (dx * dx) + (dz * dz);
                        if (r > 0.1) {
                                verb = "walk";
                        }
                }

                // multiply by speed and time increment
                const float maxSpeed = 4.5;     // 4.5m/s = 16.2 km/h = 10 mph
                //const float maxSpeed = 6.0;   // 4.5m/s = 16.2 km/h = 10 mph
                dx *= dt * mult * maxSpeed;
                dz *= dt * mult * maxSpeed;

                // update model with verb
                if (m_model) {
                        m_model->setAnimation(verb);
                }

                // here we move the viewer to get an accurate requested position
                // but the authoritative move happens with requestMove() below.
                point3d_t oldPos = m_viewer.getPosition();
                m_viewer.move(dz, dx, 0);       // forward, sideways, up
                point3d_t newPos = m_viewer.getPosition();
                delta = newPos - oldPos;

                // shoot something?
                if (iTrigger >= 0 &&
                    gamepad::eButtonWasReleased & gp->getButton(iTrigger)) {

                        event_t event;
                        event.device = eDevice_Gamepad;
                        event.event = eEvent_Press;
                        event.item = iTrigger;

                        m_host->notifyInput(m_playerId, event);
                }
        }

        // determine Euler angles
        // TODO: have glut::viewer object use these natively!
        point3d_t euler(-m_viewer.getUpRotation(),
                        m_viewer.getYRotation(),
                        0.0);

        // always send move request, just to get new position
        point3d_t newPos;
        m_host->requestMove(m_playerId, delta, euler, newPos);
        m_viewer.setPosition(newPos);

        // save old state
//      m_oldButtons = gp.buttons;
}



void
TermImpl::mouseMove
(
IN int x,
IN int y
)
{
        m_dialogManager->cursor(x, y);
}



void
TermImpl::mouseButton
(
IN int button,
IN int state,
IN int x,
IN int y
)
{
        if (state) {
                m_lastX = x;
                m_lastY = y;
        }
        m_dialogManager->button(button, state, x, y);
}



void
TermImpl::keyboard
(
IN int key,
IN int mods
)
{
        if (eMode_Cursor == m_mode) {
                m_dialogManager->keyboard(key, mods);
        } else {
                // use for motion?
        }
}



void
TermImpl::showDialog
(
IN const char * id,
IN const Datahash * dialog,
IN dialog::Host * host
)
{
        ASSERT(id, "null");
        ASSERT(dialog, "null");
        ASSERT(host, "null");

        m_dialogManager->createDialog(id, m_lastX, m_lastY, dialog, host);
}



void
TermImpl::destroyDialog
(
IN const char * id
)
{
        ASSERT(id, "null");

        m_dialogManager->destroyDialog(id);
}



void
TermImpl::notifyMap
(
IN MapKdTree * mapKdTree
)
{
        // ASSERT(dyn) -- can be null! (not in map)

        if (m_mapKdTree && !mapKdTree) {
                DPRINTF("LOSING MAP!");
        } else if (!m_mapKdTree && mapKdTree) {
                DPRINTF("Gaining map!");
                m_newMap = true;
        }

        m_mapKdTree = mapKdTree;
}



void
TermImpl::notifyInstance
(
IN smart_ptr<Instance>& instance
)
{
        // ASSERT(instance) -- can be null!

        m_instance = instance;
        if (m_instance) {
                m_model = getModel(instance);
        } else {
                m_model = NULL;
        }
}



//
//      TermImpl -- view::Host class interface methods
//

void
TermImpl::render3D
(
IN int id,
IN const view::render_info_t& ri
)
{
        perf::Timer timer("Terminal::render3D");
        ASSERT(id > 0, "Bad id: %d", id);
        ASSERT(ri.isValid(), "invalid render info?");
        ASSERT(m_rQueue, "null");

//      DPRINTF("Rendering id=%d, %d x %d, aspect=%f",
//          id, width, height, aspect);

        // create render context
        glut::render_context_t rc;
        rc.camera.setAspect(ri.width, ri.height);

        // create an actual viewer that is above position
        // (account for eyes being higher!)
        rc.viewer = m_viewer;
        point3d_t pos = rc.viewer.getPosition();
        pos.y += 0.5;
        rc.viewer.setPosition(pos);

        // render 3D scene as background
        if (m_mapKdTree) {
                drawMap(m_mapKdTree, rc, m_rQueue, m_stats);
        }
}



void
TermImpl::render2D
(
IN int id,
IN const view::render_info_t& ri
)
{
        perf::Timer timer("Terminal::render2D");
        ASSERT(id > 0, "Bad id: %d", id);

        // update fps
        m_fps.tick(perf::getNow());

        // save most recently-seen dimensions
        m_maxX = ri.width;
        m_maxY = ri.height;

        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

        // no map rendered?  clear out
        if (!m_mapKdTree) {
                glColor3f(m_back[0], m_back[1], m_back[2]);
                glRecti(0, 0, m_maxX, m_maxY);
        }
//      glRecti(viewport.left, viewport.top, viewport.right, viewport.bottom);

        // display any dialogs
        glColor3f(1.0, 1.0, 1.0);
        m_dialogManager->display(m_maxX, m_maxY);

        // the cursor (if any)
        if (eMode_Cursor == m_mode) {
                glut::drawCursor((int) m_cursor.x, (int) m_cursor.y);
        }

        // fps
        glColor3f(1.0, 1.0, 1.0);
        char buffer[128];
        sprintf(buffer, "%d fps", (int) (m_fps.getFPS() + 0.5));
        displayString(eGlutFont_Bitmap_9_by_15, 1, m_maxY - 5, -1, buffer);

        // map stats
        sprintf(buffer, "drawing %d objects", m_stats.nObjects);
        displayString(eGlutFont_Bitmap_9_by_15, 1, m_maxY - 18, -1, buffer);

        // height + width
        sprintf(buffer, "%d x %d", m_maxX, m_maxY);
        displayString(eGlutFont_Bitmap_9_by_15, m_maxX - 192, m_maxY - 5, -1,
            buffer);

        sprintf(buffer, "player id: %d", id);
        displayString(eGlutFont_Bitmap_9_by_15, m_maxX - 192, m_maxY - 21, -1,
            buffer);

        // position and facing
        if (m_mapKdTree) {
                point3d_t pos = m_viewer.getPosition();
                sprintf(buffer, "position: (%3.1f, %3.1f, %3.1f)",
                    pos.x, pos.y, pos.z);
                displayString(eGlutFont_Bitmap_9_by_15, 1, 12, -1, buffer);

                pos = m_viewer.getFacing();
                sprintf(buffer, "  facing: (%3.1f, %3.1f, %3.1f)",
                    pos.x, pos.y, pos.z);
                displayString(eGlutFont_Bitmap_9_by_15, 1, 24, -1, buffer);
        }
}




//
//      factory methods
//

smart_ptr<Terminal>
Terminal::create
(
IN TerminalHost * host,
IN int playerId,
IN smart_ptr<glut::RenderQueue>& rq
)
{
        ASSERT(host, "null");
        ASSERT(playerId > 0, "bad player id: %d", playerId);
        ASSERT(rq, "null");

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

        local->initialize(host, playerId, rq);

        return local;
}



};      // aesop namespace