gamepad-test-element.cpp

Go to the documentation of this file.

/*
 * gamepad-test-element.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 gamepad dialog Test element
 */

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

#include "datahash/datahash_util.h"
#include "gamepad-vgfx/gamepad-vgfx.h"


namespace gamepad {


static const char * s_testElementName           = "gamepadVgfxTest";


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

static float
getFloat
(
IN const pot_value_t& pv
)
throw()
{
        float delta = pv.maxSeen - pv.minSeen;
        if (delta <= 0) {
                return 0;
        }

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



////////////////////////////////////////////////////////////////////////////////
//
//      TestElement -- class that implements the dialog::Element interface
//
////////////////////////////////////////////////////////////////////////////////

class TestElement : public dialog::Element {
public:
        // constructor, destructor ---------------------------------------------
        ~TestElement(void) throw() { }

        // dialog::Element class interface methods -----------------------------
        int getWidth(void) { return m_width; }
        int getHeight(void) { return m_height; }
        void draw(IN const dialog::point_t& offset); 
        void cursor(IN const dialog::point_t& pos) { }
        const char * button(IN int button, IN int state,
                                IN const dialog::point_t& pos)
                                { return NULL; }
        void addData(IN crypto::DESKey * key, IO Datahash * data) { }

        // static factory methods ----------------------------------------------
        static smart_ptr<dialog::Element> create(IN dialog::Manager * mgr,
                                IN smart_ptr<Gamepad>& gp,
                                IN smart_ptr<vgfx::Drawer>& drawer);

private:
        // private constructors ------------------------------------------------
        TestElement(void) throw(); 

        // private typedefs ----------------------------------------------------

        // private helper methods ----------------------------------------------
        void initialize(IN dialog::Manager * mgr,
                                IN smart_ptr<Gamepad>& gp,
                                IN smart_ptr<vgfx::Drawer>& drawer);

        // private member data -------------------------------------------------
        int                             m_width;
        int                             m_height;
        smart_ptr<Gamepad>              m_gamepad;
        smart_ptr<TypeVgfxRenderer>     m_renderer;
        Type *                          m_type;
};



TestElement::TestElement
(
void
)
throw()
{
        m_type = NULL;

        m_width = 400;
        m_height = 300;
}



smart_ptr<dialog::Element>
TestElement::create
(
IN dialog::Manager * mgr,
IN smart_ptr<Gamepad>& gamepad,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(mgr, "null");
        ASSERT(gamepad, "null");
        ASSERT(drawer, "null");

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

        local->initialize(mgr, gamepad, drawer);

        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      TestElement -- dialog::Element class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
TestElement::draw
(
IN const dialog::point_t& offset
)
{
        ASSERT(m_gamepad, "null");
        ASSERT(m_type, "null");

        // anything to tweak?
        int nButtons = m_type->getInputCount(eInput_Button);
        for (int i = 0; i < nButtons; ++i) {
                float val = (eButtonDown & m_gamepad->getButton(i)) ? 1.0 : 0.5;
                const char * logical =
                    m_type->getLogicalName(eInput_Button, i);
                m_renderer->setIntensity(logical, val);
        }

        int nJoysticks = m_type->getInputCount(eInput_Joystick);
        for (int i = 0; i < nJoysticks; ++i) {
                joystick_t joy;
                m_gamepad->getJoystick(i, joy);
                float x = getFloat(joy.x);
                float y = getFloat(joy.y);
                float intensity = 0.5;
                if (x < 0.3 || x > 0.7 || y < 0.3 || y > 0.7) {
                        intensity = 1.0;
                }
                const char * logical =
                    m_type->getLogicalName(eInput_Joystick, i);
                m_renderer->setIntensity(logical, intensity);
                m_renderer->setPosition(logical, x, y);
        }

        int nPots = m_type->getInputCount(eInput_Pot);
        for (int i = 0; i < nPots; ++i) {
                pot_value_t pv;
                m_gamepad->getPot(i, pv);
                const char * logical =
                    m_type->getLogicalName(eInput_Pot, i);
                float intensity = 0.25 + 0.75 * getFloat(pv);
                m_renderer->setIntensity(logical, intensity);
        }

        int nDpads = m_type->getInputCount(eInput_Dpad);
        for (int i = 0; i < nDpads; ++i) {
                eDpad dp = m_gamepad->getDpad(i);
                float x = 0.5;
                float y = 0.5;
                if (eDpad_Left & dp)
                        x = 0;
                else if (eDpad_Right & dp)
                        x = 1;
                if (eDpad_Up & dp)
                        y = 0;
                else if (eDpad_Down & dp)
                        y = 1;

                float intensity = 0.5;
                if (x < 0.4 || x > 0.6 || y < 0.4 || y > 0.6) {
                        intensity = 1.0;
                }
                const char * logical = 
                    m_type->getLogicalName(eInput_Dpad, i);

                m_renderer->setIntensity(logical, intensity);
                m_renderer->setPosition(logical, x, y);
        }

        // now draw
        m_renderer->draw(offset.x, offset.y, m_width, m_height);
}



////////////////////////////////////////////////////////////////////////////////
//
//      TestElement -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
TestElement::initialize
(
IN dialog::Manager * mgr,
IN smart_ptr<Gamepad>& gp,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(mgr, "null");
        ASSERT(gp, "null");
        ASSERT(drawer, "null");

        m_gamepad = gp;
        ASSERT(!m_type, "already have a type?");
        m_type = gp->getType();
        ASSERT(m_type, "null type");

        m_renderer = TypeVgfxRenderer::create(m_type, drawer);
        ASSERT(m_renderer, "null");
}



////////////////////////////////////////////////////////////////////////////////
//
//      TestFactory - class that implements the dialog::Factory interface
//                      for gamepad Testing elements
//
////////////////////////////////////////////////////////////////////////////////

class TestFactory : public dialog::Factory {
public:
        // constructor, destructor ---------------------------------------------
        ~TestFactory(void) throw() { }

        // dialog::Factory class interface methods -----------------------------
        smart_ptr<dialog::Element> createElement(IN const char * type,
                                IN dialog::Manager * mgr,
                                IN const Datahash * data);

        // static factory methods ----------------------------------------------
        static smart_ptr<dialog::Factory> create(IN smart_ptr<Manager>& mgr,
                                IN smart_ptr<vgfx::Drawer>& drawer) {
                        ASSERT(mgr, "null");
                        ASSERT(drawer, "null");
                        smart_ptr<TestFactory> local = new TestFactory;
                        ASSERT(local, "out of memory");
                        local->m_mgr = mgr;
                        local->m_drawer = drawer;
                        return local;
                }
private:
        // private constructors ------------------------------------------------
        TestFactory(void) throw() { }

        // private typedefs ----------------------------------------------------
        // private member data -------------------------------------------------
        smart_ptr<Manager>      m_mgr;
        smart_ptr<vgfx::Drawer> m_drawer;
};



////////////////////////////////////////////////////////////////////////////////
//
//      TestFactory -- dialog::Factory class interface methods
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<dialog::Element>
TestFactory::createElement
(
IN const char * type,
IN dialog::Manager * mgr,
IN const Datahash * data
)
{
        ASSERT(type, "null");
        ASSERT(mgr, "null");
        ASSERT(data, "null");

        const char * index = getOptionalString(data, "gamepadId", "-1");
        int idx = atoi(index);
        int nGamepads = m_mgr->getGamepadCount();
        ASSERT_THROW(idx >= 0 && idx < nGamepads,
            "Bad gamepad index: '" << index << "'");

        smart_ptr<Gamepad> gamepad = m_mgr->getGamepad(idx);
        ASSERT_THROW(gamepad, "gamepad does not exist: " << idx);

        ASSERT_THROW(!strcmp(type, s_testElementName),
           "Bad test element type: " << type);

        return TestElement::create(mgr, gamepad, m_drawer);
}




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

void
registerVgfxTestFactory
(
IN smart_ptr<Manager>& gamepadMgr,
IN dialog::Manager * dialogMgr,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(gamepadMgr, "null");
        ASSERT(dialogMgr, "null");
        ASSERT(drawer, "null");

        smart_ptr<dialog::Factory> factory =
            TestFactory::create(gamepadMgr, drawer);
        ASSERT(factory, "null");

        dialogMgr->registerFactory(s_testElementName, factory);
}



const char *
getVgfxTestElementName
(
void
)
throw()
{
        return s_testElementName;
}



};      // gamepad namespace