source-device.cpp

Go to the documentation of this file.

/*
 * source-device.cpp
 *
 * Copyright (C) 2009  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.
 *
 *
 * See source-device.h
 */

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

namespace gamepad {


/// interface destructors
SourceDevice::~SourceDevice(void) throw() { }
SourceDeviceFactory::~SourceDeviceFactory(void) throw() { }



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

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

byte_t
updateButton
(
IN byte_t oldButton,
IN bool isButtonDown
)
throw()
{
        if (isButtonDown) {
                // button is down now.  Was it down before?
                if (eButtonDown & oldButton) {
                        // button was already down!  no change...
                } else {
                        // need to set "was pushed" and "is down" bits
                        oldButton |= eButtonWasPushed;          
                        oldButton |= eButtonDown;
                }
        } else {
                // button is up now.  Was it down before?
                if (eButtonDown & oldButton) {
                        // DPRINTF("old:0x%02x", oldButton);

                        // button was recorded as down before
                        // need to clear "is down" bit
                        oldButton &= ~eButtonDown;

                        // set "was released" bit
                        oldButton |= eButtonWasReleased;
                } else {
                        // button was already up!  no change
                }
        }

        return oldButton;
}



void
snapshotState
(
IN SourceDevice * device,
OUT device_state_t& state
)
{
        ASSERT(device, "null");
        state.clear();

        // loop through all pots and set their values
        state.nPots = device->getNumPots();
        ASSERT_THROW(state.nPots <= device_state_t::eMaxPots,
            "Source device has too many potentiometers: " << state.nPots);
        for (int i = 0; i < state.nPots; ++i) {
                state.pot[i] = device->getPotValue(i);
        }

        // loop through all buttons and set their values
        state.nButtons = device->getNumButtons();
        ASSERT_THROW(state.nButtons <= device_state_t::eMaxButtons,
            "Source device has too many buttons: " << state.nButtons);
        for (int i = 0; i < state.nButtons; ++i) {
                state.button[i] = device->getButtonValue(i);
        }
}



int
buttonDown
(
IN const device_state_t& s
)
{
        int retval = -1;
        for (int i = 0; i < s.nButtons; ++i) {
                if (s.button[i] & eButtonDown) {
                        // button is down
                        if (retval > -1) {
                                // multiple buttons are down
                                return -1;
                        }
                        retval = i;
                }
        }
        return retval;
}



int
buttonChanged
(
IN const device_state_t& s0,
IN const device_state_t& s1
)
{
        ASSERT_THROW(s0.nButtons == s1.nButtons,
            "State snapshots don't match button count?");

        int retval = -1;        // nothing changed
        for (int i = 0; i < s0.nButtons; ++i) {
                if (s0.button[i] != s1.button[i]) {
                        // changed!
                        if (retval > -1) {
                                // another button also changed
                                DPRINTF("multiple button state changes");
                                return -1;
                        }
                        retval = i;
                }
        }

        return retval;
}



int
buttonReleased
(
IN const device_state_t& s
)
{
        int retval = -1;
        for (int i = 0; i < s.nButtons; ++i) {
                if (eButtonWasReleased & s.button[i]) {
                        if (retval > -1) {
                                // another button was also released!
                                DPRINTF("multiple button releases");
                                return -1;
                        }
                        retval = i;
                }
        }

        return retval;
}



bool
potsCalibrated
(
IN const device_state_t& s0,
IN const device_state_t& s1
)
{
        ASSERT_THROW(s0.nPots == s1.nPots,
            "State snapshots have different potentiometer counts?  " <<
            s0.nPots << " vs. " << s1.nPots);

        for (int i = 0; i < s0.nPots; ++i) {
                const pot_value_t& p0 = s0.pot[i];
                const pot_value_t& p1 = s1.pot[i];

                if (p0.minSeen == p0.maxSeen ||
                    p0.minSeen != p1.minSeen ||
                    p0.maxSeen != p1.maxSeen) {
                        DPRINTF("Still calibrating potentiometers (%d)", i);
                        DPRINTF("  p0.min=%d   p0.max=%d", p0.minSeen, p0.maxSeen);
                        DPRINTF("  p1.min=%d   p1.max=%d", p1.minSeen, p1.maxSeen);
                        return false;
                }
        }

        return true;
}



int
maxPotValue
(
IN const device_state_t& state,
IN float threshold
)
{
        ASSERT(threshold >= 0.0 && threshold <= 1.0,
            "Bad threshold: %f", threshold);

        int retval = -1;
        float max = threshold;
        
        for (int i = 0; i < state.nPots; ++i) {
                const pot_value_t& p0 = state.pot[i];

                if (p0.minSeen == p0.maxSeen) {
                        // skip this pot
                        continue;
                }

                float val = (p0.value - p0.minSeen) / (p0.maxSeen - p0.minSeen);

                if (val > max) {
                        retval = i;
                        max = val;
                }
        }

        return retval;
}



int
maxPotChanged
(
IN const device_state_t& s0,    // old state
IN const device_state_t& s1     // new state
)
{
        ASSERT_THROW(s0.nPots == s1.nPots,
            "State snapshots have different potentiometer counts?  " <<
            s0.nPots << " vs. " << s1.nPots);

        int retval = -1;
        float delta = 0.4;      // pots should change by 40% or more

        for (int i = 0; i < s0.nPots; ++i) {
                const pot_value_t& p0 = s0.pot[i];
                const pot_value_t& p1 = s1.pot[i];

                if (!p0.isValid() || !p1.isValid() ||
                    p0.minSeen != p1.minSeen ||
                    p0.maxSeen != p1.maxSeen) {
                        // skip this pot
                        DPRINTF("Skipping non-calibrated [%d]...\n", i);
                        continue;
                }

                float dv = (1.0 * (p1.value - p0.value)) / (p1.maxSeen - p1.minSeen);
                if (dv < 0) {
                        dv = -dv;
                }
                DPRINTF("  pot[%d]: dv=%f  (min=%d, max=%d, v0=%d, v1=%d)",
                    i, dv, p1.minSeen, p1.maxSeen, p0.value, p1.value);
                if (dv > delta) {
                        delta = dv;
                        retval = i;
                }
        }

        return retval;
}



};      // gamepad namespace