PhxRawInputEngine.h

Go to the documentation of this file.

#ifndef PHX_RAW_INPUT_ENGINE_H
#define PHX_RAW_INPUT_ENGINE_H

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

namespace Phx {

  class RawInputEngine : public NamedInterface {
    class ButtonStateClass;
    class ButtonIdentifierClass;
    class AxisIdentifierClass;
  public:
    const static NamedInterface::Type INTERFACE_TYPE;
    const static String               INTERFACE_TYPE_NAME;

    const static NamedInterface::Identifier RAW_INPUT_ENGINE_IDENTIFIER;
    const static String                     RAW_INPUT_ENGINE_NAME;

    typedef uint32_t AxisState;
    typedef ValueType<AxisIdentifierClass, uint32_t>  AxisIdentifier;
    const static AxisIdentifier  INVALID_AXIS_IDENTIFIER;

    typedef ValueType<ButtonIdentifierClass, uint32_t>  ButtonIdentifier;
    const static ButtonIdentifier  INVALID_BUTTON_IDENTIFIER;

    typedef ValueType<ButtonStateClass, uint32_t> ButtonState;
    const static ButtonState PRESSED;
    const static ButtonState RELEASED;


    class Driver;
    class Client;
    
    virtual ~RawInputEngine() {}

    class Listener : public BaseListener<RawInputEngine, Listener> {
    public:
      virtual void onNewDriver(const String& driverName) = 0;
      virtual void onDeleteDriver(const String& driverName) = 0;
    };

    virtual Ptr<Driver> newDriver(const String& driverName) = 0;

    virtual Ptr<Client> newClient(const String& driverName) = 0;

    virtual std::vector<String> driverNames(void) const = 0;

    virtual void listener(Listener* listener) = 0;
  };

  class RawInputEngine::Driver : public LockedPtrInterface<Driver> {
  public:
    typedef RawInputEngine::ButtonIdentifier ButtonIdentifier;
    typedef RawInputEngine::AxisIdentifier   AxisIdentifier;
    typedef RawInputEngine::ButtonState ButtonState;
    typedef RawInputEngine::AxisState   AxisState;

    // virtual destructor
    virtual ~Driver() {}

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

    virtual void listener(Listener* listener) = 0;
    
    virtual void buttonName(ButtonIdentifier button, const String& name) = 0;
    
    virtual String buttonName(ButtonIdentifier button) const = 0;
    
    // virtual ButtonIdentifier nameButton(const String& name) = 0;
    
    virtual void buttonState(ButtonIdentifier button, ButtonState state) = 0;
    
    virtual ButtonState buttonState(ButtonIdentifier button) const = 0;
    
    virtual void axisName(AxisIdentifier axis, const String& name) = 0;
    
    virtual String axisName(AxisIdentifier axis) const = 0;

    // virtual AxisIdentifier nameAxis(const String& name) = 0;
    
    virtual void axisState(AxisIdentifier axis, AxisState state) = 0;
    
    virtual AxisState axisState(AxisIdentifier axis) const = 0;

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

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

  class RawInputEngine::Client : public LockedPtrInterface<Client> {
  public:
    typedef RawInputEngine::ButtonIdentifier ButtonIdentifier;
    typedef RawInputEngine::AxisIdentifier   AxisIdentifier;
    typedef RawInputEngine::ButtonState ButtonState;
    typedef RawInputEngine::AxisState   AxisState;

    // virtual destructor
    virtual ~Client() {}

    class Listener : public BaseListener<Client, Listener> {
    public:
      virtual void onAxisState(AxisIdentifier axis) = 0;
      virtual void onButtonState(ButtonIdentifier button) = 0;
    };

    virtual void listener(Listener* listener) = 0;

    virtual String buttonName(ButtonIdentifier button) const = 0;

    virtual ButtonState buttonState(ButtonIdentifier button) const = 0;

    virtual ButtonState previousButtonState(ButtonIdentifier button) const = 0;

    virtual String axisName(AxisIdentifier axis) const = 0;

    virtual AxisState axisState(AxisIdentifier axis) const = 0;

    virtual AxisState previousAxisState(AxisIdentifier axis) const = 0;

    virtual std::vector<ButtonIdentifier> buttonIdentifiers(void) const = 0;

    virtual std::vector<AxisIdentifier> axisIdentifiers(void) const = 0;

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

  protected:
    void setDriverName(const String& driverName) { mDriverName = driverName; }
  private:
    String mDriverName;
  };
  
  
  // drivers
  //   digital buttons
  //   analogue axes
  
  // clients
  //   button press, release, hold notification
  //   
  
  // binder drivers
  //   digital buttons -> buttons, actions
  //   analogue axes -> sticks, dials, cursors
  //   digital buttons -> sticks, dials, cursors


  //                gui binders
  //                   V
  //             logical-raw binder
  //              ^             |
  //              |             V 
  //           raw input     logical input --> clients
  //

  // Notes:
  // Current interface uses sub-interfaces to provide a mechanism through
  // which drivers deposit their input into the InputEngine.  Alternative:
  // Have drivers implement an accessory interface to the InputEngine and
  // allow the InputEngine to poll that interface.
  //
  // Current method:
  // Pros
  //   Easy to understand;  no interface for driver to implement.
  //   Allows driver to be given time for its update from within input layer.
  //   Also allows driver to deposit its own 
  //


}; // namespace Phx

#endif /* PHX_RAW_INPUT_ENGINE_H */

---