PhxLogicalInputEngine.h

Go to the documentation of this file.

#ifndef PHX_LOGICAL_INPUT_H
#define PHX_LOGICAL_INPUT_H

#include <Phx/PhxConfig.h>
#include <Phx/PhxTypes.h>
#include <Phx/Core/PhxNamedInterface.h>
#include <Phx/Input/PhxRawInputEngine.h>
#include <Phx/Util/PhxListeners.h>
#include <Phx/Util/PhxLocks.h>
#include <vector>

namespace Phx {

  class LogicalInputEngine : public NamedInterface {
    class ButtonStateClass;
  public:
    const static NamedInterface::Type INTERFACE_TYPE;
    const static String INTERFACE_TYPE_NAME;

    const static NamedInterface::Identifier LOGICAL_INPUT_ENGINE_IDENTIFIER;
    const static String LOGICAL_INPUT_ENGINE_NAME;

    typedef double AxisState;

    typedef ValueType<ButtonStateClass, uint8_t> ButtonState;

    const static ButtonState PRESSED;
    const static ButtonState RELEASED;

    class AxisClient;
    class ButtonClient;

    class AxisSpec;
    class ButtonSpec;
    class ButtonSpecState;

    class AxisDriver;
    class ButtonDriver;

    class AnalogAxisDriver;
    class DigitalAxisDriver;
    class AnalogButtonDriver;
    class DigitalButtonDriver;

    // Sets the input engine to which this logical layer is bound.
    // In the future, will likely use the datagram system to specify the
    // identifier of the input engine to use, and thus you will not be able
    // to change the input layer after the logical layer is constructed.
    // InUseException when engine already set.
    virtual void rawInputEngine(const Ptr<RawInputEngine>& rawInputEngine) = 0;

    virtual Ptr<AxisClient> newAxisClient(const String& axisName) = 0;

    virtual Ptr<ButtonClient> newButtonClient(const String& buttonName) = 0;


    virtual Ptr<AnalogAxisDriver> newAnalogAxisDriver(const String& axisName) = 0;

    virtual Ptr<DigitalAxisDriver> newDigitalAxisDriver(const String& axisName) = 0;

    virtual Ptr<AnalogButtonDriver> newAnalogButtonDriver(const String& buttonName) = 0;

    virtual Ptr<DigitalButtonDriver> newDigitalButtonDriver(const String& buttonName) = 0;


    class Listener : public BaseListener<LogicalInputEngine, Listener> {
    public:
      virtual void onNewAxisClient(const String& axisName) = 0;
      virtual void onNewButtonClient(const String& buttonName) = 0;
    };

    virtual void listener(Listener* listener) = 0;

  protected:
    LogicalInputEngine() {}
  private:
    LogicalInputEngine(LogicalInputEngine&);
    LogicalInputEngine& operator=(LogicalInputEngine&);
  };
    

  class LogicalInputEngine::AxisClient :
    public LockedPtrInterface<AxisClient> {
  public:

    class Listener : public BaseListener<AxisClient, Listener> {
    public:
      virtual void onAxisState(void) = 0;
    };

    virtual void listener(Listener* listener) = 0;

    virtual AxisState axisState(void) const = 0;

    const String& name(void) const { return mName; }

  protected:
    void setName(const String& name) { mName = name; }
  private:
    String mName;
  };


  class LogicalInputEngine::ButtonClient :
    public LockedPtrInterface<ButtonClient> {
  public:

    class Listener : public BaseListener<ButtonClient, Listener> {
    public:
      virtual void onButtonState(void) = 0;
    };

    virtual void listener(Listener* listener) = 0;

    virtual ButtonState buttonState(void) const = 0;

    const String& name(void) const { return mName; }

  protected:
    void setName(const String& name) { mName = name; }
  private:
    String mName;
  };



  class LogicalInputEngine::AxisDriver :
    public LockedPtrInterface<AxisDriver> {
  public:
    typedef LogicalInputEngine::AxisState AxisState;

    virtual AxisState axisState(void) const = 0;

    const String& name(void) const { return mName; }

  protected:
    AxisDriver() {}
    void setName(const String& name) { mName = name; }

  private:
    String mName;

    AxisDriver(AxisDriver&);
    AxisDriver& operator=(AxisDriver&);
  };


  class LogicalInputEngine::ButtonDriver :
    public LockedPtrInterface<ButtonDriver> {
  public:
    typedef LogicalInputEngine::ButtonState ButtonState;

    virtual ButtonState buttonState(void) const = 0;

    const String& name(void) const { return mName; }

  protected:
    ButtonDriver() {}
    void setName(const String& name) { mName = name; }

  private:
    String mName;

    ButtonDriver(ButtonDriver&);
    ButtonDriver& operator=(ButtonDriver&);
  };



  class LogicalInputEngine::AxisSpec {
  public:
    const static AxisSpec INVALID;

    AxisSpec() : mDriverName(""), mIdentifier(RawInputEngine::INVALID_AXIS_IDENTIFIER) {}

    AxisSpec(const String& driverName, RawInputEngine::AxisIdentifier identifier) :
      mDriverName(driverName), mIdentifier(identifier) { 
    }

    // default copy and assignment okay

    // comparisons

    bool operator==(const AxisSpec& b) const {
      return (mDriverName == b.mDriverName &&
              mIdentifier == b.mIdentifier);
    }

    bool operator!=(const AxisSpec& b) const { return !(b==*this); }

    const String& driverName() const { return mDriverName; }

    RawInputEngine::AxisIdentifier identifier() const { return mIdentifier; }

  private:
    String  mDriverName;
    RawInputEngine::AxisIdentifier mIdentifier;
  };
  
  
  class LogicalInputEngine::ButtonSpec {
  public:
    const static ButtonSpec INVALID;

    ButtonSpec() : mDriverName(""), mIdentifier(RawInputEngine::INVALID_BUTTON_IDENTIFIER) {}

    ButtonSpec(const String& driverName, RawInputEngine::ButtonIdentifier identifier) :
      mDriverName(driverName), mIdentifier(identifier) { }

    // default copy and assignment okay

    // comparisons

    bool operator==(const ButtonSpec& b) const {
      return (mDriverName == b.mDriverName &&
              mIdentifier == b.mIdentifier);
    }

    bool operator!=(const ButtonSpec& b) const { return !(*this==b); }

    // attribute accessors (read-only)

    const String& driverName() const { return mDriverName; }

    RawInputEngine::ButtonIdentifier identifier() const { return mIdentifier; }

  private:
    String  mDriverName;
    RawInputEngine::ButtonIdentifier mIdentifier;
  };

  class LogicalInputEngine::ButtonSpecState {
  public:

    ButtonSpecState() : mTriggerState(RawInputEngine::PRESSED) {}

    ButtonSpecState(const String& driverName, RawInputEngine::ButtonIdentifier button,
                    RawInputEngine::ButtonState triggerState) :
      mButtonSpec(driverName, button), mTriggerState(triggerState) {}

    ButtonSpecState(const LogicalInputEngine::ButtonSpec& buttonSpec,
                    RawInputEngine::ButtonState triggerState) :
      mButtonSpec(buttonSpec), mTriggerState(triggerState) {}

    // default copy/assignment okay

    bool operator==(const ButtonSpecState& b) {
      return (b.mButtonSpec == mButtonSpec &&
              b.mTriggerState == mTriggerState);
    }

    bool operator!=(const ButtonSpecState& b) {
      return !(*this == b);
    }

    const LogicalInputEngine::ButtonSpec& buttonSpec() const { return mButtonSpec; }

    RawInputEngine::ButtonState triggerState() const { return mTriggerState; }

  private:
    LogicalInputEngine::ButtonSpec mButtonSpec;
    RawInputEngine::ButtonState    mTriggerState;
  };

  class LogicalInputEngine::AnalogAxisDriver :
    public LogicalInputEngine::AxisDriver {
  public:

    virtual void axis(const AxisSpec& axis) = 0;

    virtual AxisSpec axis(void) const = 0;

    virtual void axisMax(RawInputEngine::AxisState axisMax) = 0;

    virtual RawInputEngine::AxisState axisMax(void) const = 0;
    
    virtual void axisCenter(RawInputEngine::AxisState axisCenter) = 0;

    virtual RawInputEngine::AxisState axisCenter(void) const = 0;

    virtual void axisMin(RawInputEngine::AxisState axisMin) = 0;

    virtual RawInputEngine::AxisState axisMin(void) const = 0;

  protected:
    AnalogAxisDriver() {}
  private:
    // no copy or assignment
    AnalogAxisDriver(AnalogAxisDriver&);
    AnalogAxisDriver& operator=(AnalogAxisDriver&);
  };

  class LogicalInputEngine::DigitalAxisDriver :
    public LogicalInputEngine::AxisDriver {
  public:
    typedef LogicalInputEngine::AxisState AxisState;

    virtual void increaseButtons(const std::vector<ButtonSpecState>& buttons) = 0;

    virtual std::vector<ButtonSpecState> increaseButtons(void) const = 0;

    virtual void centerButtons(const std::vector<ButtonSpecState>& buttons) = 0;

    virtual std::vector<ButtonSpecState> centerButtons(void) const = 0;


    virtual void decreaseButtons(const std::vector<ButtonSpecState>& buttons) = 0;

    virtual std::vector<ButtonSpecState> decreaseButtons(void) const = 0;

    virtual void continuous(bool continuous) = 0;
    
    virtual bool continuous(void) const = 0;

    virtual void rate(AxisState rate) = 0;
    virtual AxisState rate(void) const = 0;

    virtual void max(AxisState max) = 0;

    virtual AxisState max(void) const = 0;

    virtual void min(AxisState min) = 0;

    virtual AxisState min(void) const = 0;
  };


  class LogicalInputEngine::AnalogButtonDriver :
    public LogicalInputEngine::ButtonDriver {
  public:

    virtual void axis(const AxisSpec& axis) = 0;

    virtual AxisSpec axis(void) const = 0;

    virtual void threshold(RawInputEngine::AxisState threshold) = 0;

    virtual RawInputEngine::AxisState threshold(void) const = 0;

    virtual void inverted(bool invert) = 0;

    virtual bool inverted(void) const = 0;
  };

  class LogicalInputEngine::DigitalButtonDriver :
    public LogicalInputEngine::ButtonDriver {
  public:

    virtual void buttons(const std::vector<ButtonSpecState>& buttons) = 0;

    virtual std::vector<ButtonSpecState> buttons(void) const = 0;
  };


}; // namespace Phx

#endif /* PHX_LOGICAL_INPUT_H */

---