gamepad-vgfx.cpp

Go to the documentation of this file.

/*
 * gamepad-vgfx.cpp
 *
 * Copyright (C) 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 gamepad Type drawer using the vector graphics engine
 * (vgfx).
 */

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

#include "color/color.h"
#include "perf/perf.h"
#include "vgfx/request.h"
#include "vgfx/vgfx.h"


namespace gamepad {


// interface destructors
TypeVgfxRenderer::~TypeVgfxRenderer(void) throw() { }


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

static void
addFloat
(
IN dictionary_t& data,
IN const char * key,
IN float val
)
{
        ASSERT(key, "null");

        const int bufsize = 32;
        char buffer[bufsize];

        snprintf(buffer, bufsize, "%f", val);

        data[key] = buffer;
}



static bool
getField
(
IN vgfx::ObjectMap * map,
IN const char * id,
IN const char * field,
OUT std::string& value
)
{
        ASSERT(map, "null");
        ASSERT(id, "null");
        ASSERT(field, "null");
        value = "";

        vgfx::Primitive * obj = map->findObject(id);
        if (!obj)
                return false;   // no such object?

        VecString path;
        path.push_back("meta");
        path.push_back(field);

        dictionary_t data;

        if (!obj->doesContainerExist(path)) {
                return false;   // no such container (field)
        }

        obj->getContainerDictionary(path, data);
        const char * val = getValue(data, field);
        if (!val)
                return false;   // weird
        value = val;
        return true;
}



static void
addOrMoveObject
(
IN vgfx::ObjectMap * map,
IN vgfx::Drawer * drawer,
IN const char * baseId,
IN const char * newId,
IN float x,
IN float y,
IN float phi
)
{
        ASSERT(map, "null");
        ASSERT(drawer, "null");
        ASSERT(baseId, "null");
        ASSERT(newId, "null");

        // does object already exist?
        vgfx::Primitive * root = map->findObject("root");
        ASSERT_THROW(root, "gamepad vector graphics contains no 'root'?");

        VecString path;
        path.push_back("object");
        path.push_back(newId);

        if (!root->doesContainerExist(path)) {
                // object does not exist--add it!
                vgfx::Request req;
                req.addObject("root", newId, baseId, x, y, 0, phi);
                std::string request = req.get();
                //DPRINTF("Request:\n%s", request.c_str());
                std::istringstream iss(request.c_str());
                std::string undo, diagnostic;
                ASSERT_THROW(vgfx::processRequest(map, iss, false, undo, diagnostic),
                    "Failed to add new object: " << diagnostic);

                // recalc bounding rect
                xform_2d_t T;
                T.setIdentity();
                root->recalcBoundingRect("*", drawer, T);
                return;
        }

        // just need to move!
        dictionary_t data;
        addFloat(data, "x", x);
        addFloat(data, "y", y);
        addFloat(data, "phi", phi);

        root->setContainerDictionary(path, data);
}



static void
removeObject
(
IN vgfx::ObjectMap * map,
IN const char * id
)
{
        ASSERT(map, "null");
        ASSERT(id, "null");

        // delete!
        vgfx::Primitive * root = map->findObject("root");
        ASSERT_THROW(root, "gamepad vector graphics contains no 'root'?");

        VecString path;
        path.push_back("object");
        path.push_back(id);

        if (root->doesContainerExist(path)) {
                root->removeContainer(path);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      Renderer -- class that implements the gamepad::TypeVgfxRenderer
//              interface.
//
////////////////////////////////////////////////////////////////////////////////

class Renderer : public TypeVgfxRenderer {
public:
        // constructor, destructor ---------------------------------------------
        Renderer(void) throw();
        ~Renderer(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN Type * type,
                                IN smart_ptr<vgfx::Drawer>& drawer);

        // gamepad::TypeVgfxRenderer class interface methods -------------------
        void setIntensity(IN const char * logical, IN float intensity);
        void setPosition(IN const char * logical,
                                IN float x, IN float y);
        void draw(IN int xOffest, IN int yOffset,
                                IN int width, IN int height);

private:
        // private typedefs ----------------------------------------------------
        struct logical_rec_t {
                // constructor, manipulators
                logical_rec_t(void) throw() { this->clear(); }
                void clear(void) throw() {
                                baseColor.clear();
                        }

                // data fields
                glut_color_t    baseColor;
        };

        typedef std::map<std::string, logical_rec_t> logical_map_t;

        // private helper methods ----------------------------------------------
        float getScaling(IN int width, IN int height);
        logical_rec_t * getLogical(IN const char * logical);
        void setJoystick(IN logical_rec_t * plr,
                                IN vgfx::Primitive * obj,
                                IN const char * logical,
                                IN float x, IN float y);
        void setDpad(IN logical_rec_t * plr,
                                IN vgfx::Primitive * obj,
                                IN const char * logical,
                                IN float x, IN float y);

        // private member data -------------------------------------------------
        smart_ptr<vgfx::ObjectMap>      m_objectMap;
        smart_ptr<vgfx::Drawer>         m_drawer;
        vgfx::Primitive *               m_vgfxRoot;
        vgfx::rect_t                    m_rect; // native bounding rect (cm)
        Type *                          m_type;
        logical_map_t                   m_logicals;
};



Renderer::Renderer
(
void
)
throw()
{
        m_type = NULL;
        m_vgfxRoot = NULL;
}



void
Renderer::initialize
(
IN Type * type,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(type, "null");
        ASSERT(drawer, "null");
        ASSERT(!m_type, "already have a type?");
        ASSERT(!m_drawer, "already have a drawer?");
        ASSERT(!m_vgfxRoot, "already have a root object?");

        m_type = type;
        m_drawer = drawer;

        // try our best to create a vector graphics object...
        smart_ptr<nstream::Stream> vgfx = m_type->getVgfx();
        if (!vgfx) {
                DPRINTF("Type '%s' has no vector graphics object",
                    m_type->getName());
                return;
        }
//      DPRINTF("Have vector graphics!");

        m_objectMap = vgfx::ObjectMap::create();
        ASSERT(m_objectMap, "null");

        std::istream& stream = vgfx->getStream();
        std::string undo, diagnostic;
        if (!vgfx::processRequest(m_objectMap, stream, false,
            undo, diagnostic)) {
                DPRINTF("ERROR PARSING VGFX FILE:\n%s", diagnostic.c_str());
                return;
        }
//      DPRINTF("Finished parsing, object map contains %d objects",
//          (int) m_objectMap->size());

        m_vgfxRoot = m_objectMap->findObject("root");
        if (!m_vgfxRoot) {
                DPRINTF("ERROR: vector graphics does not contain a root element");
                return;
        }
//      DPRINTF("Successfully loaded vector graphics!");

        // refresh bounding rectangle
        xform_2d_t T;
        T.setIdentity();
        m_vgfxRoot->recalcBoundingRect("*", m_drawer, T);

        // get rect
        m_vgfxRoot->getBoundingRect(m_rect);
//      m_rect.dump("Bounding rect");

        // run through and set all colors
        VecString names;
        m_type->getAllInputs(names);
        for (VecString::const_iterator i = names.begin(); i != names.end();
             ++i) {
                const char * logical = i->c_str();

                logical_rec_t lr;
                lr.baseColor.set(1, 1, 1, 1);

                vgfx::Primitive * obj = m_objectMap->findObject(logical);
                if (!obj) {
                        DPRINTF("ERROR: vgfx file is missing logical control: '%s",
                            logical);
                } else {
                        VecString path;
                        path.push_back("meta");
                        path.push_back("vgfxColor");

                        if (obj->doesContainerExist(path)) {
                                dictionary_t data;
                                obj->getContainerDictionary(path, data);
                                const char * color =
                                    getOptionalValue(data, "vgfxColor", "");
                //              DPRINTF("Color: '%s'", color);

                                img_color_t ic;
                                getImgColorFromString(color, ic);
                                const float inv = 1.0 / 255.0;
                                lr.baseColor.set(inv * ic.red, inv * ic.green,
                                    inv * ic.blue, inv * ic.alpha);
                        } else {
                                // DPRINTF("No such path!");
                        }
                }

                // add this logical element's record
                m_logicals[logical] = lr;
        }
//      DPRINTF("Logical map contains %d entries", (int) m_logicals.size());
}



////////////////////////////////////////////////////////////////////////////////
//
//      Renderer -- gamepad::TypeVgfxRenderer class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
Renderer::setIntensity
(
IN const char * logical,
IN float intensity
)
{
        ASSERT(logical, "null");
        ASSERT(intensity >= 0 && intensity <= 1,
            "Bad intensity: %f", intensity);

        // look up the logical element
        logical_rec_t * plr = this->getLogical(logical);
        if (!plr)
                return;

        // get the scaled color
        int iR = (int) (255.0 * intensity * plr->baseColor.red);
        int iG = (int) (255.0 * intensity * plr->baseColor.green);
        int iB = (int) (255.0 * intensity * plr->baseColor.blue);
        int iA = (int) (255.0 * plr->baseColor.alpha);

        const int bufsize = 256;
        char buffer[bufsize];
        snprintf(buffer, bufsize, "r %d g %d b %d a %d", iR, iG, iB, iA);
        //DPRINTF("New color: '%s'", buffer);

        // set up the dictionary
        dictionary_t data;
        data["vgfxColor"] = buffer;

        // set dictionary on object
        VecString path;
        path.push_back("meta");
        path.push_back("vgfxColor");

        vgfx::Primitive * obj = m_objectMap->findObject(logical);
        if (!obj) {
                DPRINTF("No such object in vgfx file: '%s'", logical);
                return;
        }

        obj->setContainerDictionary(path, data);
}



void
Renderer::setPosition
(
IN const char * logical,
IN float x,
IN float y
)
{
        ASSERT(logical, "null");
        ASSERT(x >= 0 && x <= 1, "bad x: %f", x);
        ASSERT(y >= 0 && y <= 1, "bad y: %f", y);

        // look up the logical element
        logical_rec_t * plr = this->getLogical(logical);
        if (!plr)
                return;

        // find the graphics primitive for this object
        vgfx::Primitive * obj = m_objectMap->findObject(logical);
        if (!obj)
                return;

        eInputType itype = m_type->getInputTypes(logical);
        if (eInput_Joystick & itype) {
                this->setJoystick(plr, obj, logical, x, y);
        } else if (eInput_Dpad & itype) {
                this->setDpad(plr, obj, logical, x, y);
        } else if (eInput_Pot & itype) {
//              this->setPot(obj, plr, logical);
        } else {
                // don't do anything for buttons!
        }
}



void
Renderer::draw
(
IN int xOffset,
IN int yOffset,
IN int width,
IN int height
)
{
        perf::Timer timer("TypeVgfx::draw");
        if (!m_vgfxRoot)
                return;
        ASSERT(m_drawer, "null");

        float scaling = this->getScaling(width, height);

        xform_2d_t translate;
        translate.setIdentity();
        translate.setTranslate(xOffset, yOffset);

        xform_2d_t scale;
        scale.setTranslate(-m_rect.left, -m_rect.top);
        scale.scale(scaling);

        xform_2d_t T;
        T.setToProductOf(translate, scale);

        vgfx::rect_t r(xOffset, yOffset, xOffset + width, yOffset + height);

        // use antialiasing!
        m_vgfxRoot->draw(m_drawer, r, T);
}



////////////////////////////////////////////////////////////////////////////////
//
//      Renderer -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

float
Renderer::getScaling
(
IN int width,
IN int height
)
{
        ASSERT(width > 0, "bad width: %d", width);
        ASSERT(height > 0, "bad height: %d", height);

        float cmX = m_rect.right - m_rect.left;
        float cmY = m_rect.bottom - m_rect.top;

        float pixelsPerCmX = width / cmX;
        float pixelsPerCmY = height / cmY;

        if (pixelsPerCmX > pixelsPerCmY) {
                return pixelsPerCmY;
        } else {
                return pixelsPerCmX;
        }
}



Renderer::logical_rec_t *
Renderer::getLogical
(
IN const char * logical
)
{
        ASSERT(logical, "null");

        logical_map_t::iterator i = m_logicals.find(logical);
        if (m_logicals.end() == i) {
                return NULL;
        }
        return &i->second;
}



void
Renderer::setJoystick
(
IN logical_rec_t * plr,
IN vgfx::Primitive * obj,
IN const char * logical,
IN float x,
IN float y
)
{
        ASSERT(plr, "null");
        ASSERT(obj, "null");
        ASSERT(logical, "null");
        ASSERT(x >= 0 && x <= 1, "bad x: %f", x);
        ASSERT(y >= 0 && y <= 1, "bad y: %f", y);

        // DPRINTF("Joystick: x=%5.3f  y=%5.3f", x, y);

        // does the joystick position object exist?
        VecString path;
        path.push_back("object");
        path.push_back("pos");
        if (!obj->doesContainerExist(path))
                return;

        x -= 0.5;
        y -= 0.5;

        dictionary_t data;
        addFloat(data, "x", x);
        addFloat(data, "y", y);

        obj->setContainerDictionary(path, data);
}



void
Renderer::setDpad
(
IN logical_rec_t * plr,
IN vgfx::Primitive * obj,
IN const char * logical,
IN float x,
IN float y
)
{
        ASSERT(plr, "null");
        ASSERT(obj, "null");
        ASSERT(logical, "null");
        ASSERT(x >= 0 && x <= 1, "bad x: %f", x);
        ASSERT(y >= 0 && y <= 1, "bad y: %f", y);

        if (!m_vgfxRoot)
                return;

        // get dpad position
        xform_2d_t T;
        T.setIdentity();
        vgfx::visit_result_t vr;
        m_vgfxRoot->getPrimitive(logical, T, vr);
        if (!vr.p) {
                DPRINTF("Error: root object does not contain '%s'", logical);
                return;
        }
        vgfx::point_t p(0, 0);
        vgfx::point_t q = vr.T * p;
        //q.dump(logical);

        // what is the name of the "up" object?
        std::string name;
        if (!getField(m_objectMap, logical, "up", name)) {
                DPRINTF("Element '%s' does not contain 'up' meta field", logical);
                return;
        }
        //DPRINTF("Using name = '%s'", name.c_str());

        std::string xName = logical;
        xName += "UpX";
        std::string yName = logical;
        yName += "UpY";

        // set x-axis position
        if (x < 0.25) {
                // left!
                addOrMoveObject(m_objectMap, m_drawer, name.c_str(), xName.c_str(), q.x, q.y, -90);
        } else if (x > 0.75) {
                // right!
                addOrMoveObject(m_objectMap, m_drawer, name.c_str(), xName.c_str(), q.x, q.y, +90);
        } else {
                // nothing!
                removeObject(m_objectMap, xName.c_str());
        }

        // set y-axis position
        if (y < 0.25) {
                // up!
                addOrMoveObject(m_objectMap, m_drawer, name.c_str(), yName.c_str(), q.x, q.y, +0);
        } else if (y > 0.75) {
                // down!
                addOrMoveObject(m_objectMap, m_drawer, name.c_str(), yName.c_str(), q.x, q.y, +180);
        } else {
                // nothing
                removeObject(m_objectMap, yName.c_str());
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<TypeVgfxRenderer>
TypeVgfxRenderer::create
(
IN Type * type,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(type, "null");
        ASSERT(drawer, "null");

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

        local->initialize(type, drawer);

        return local;
}



};      // gamepad namespace