tb_input_action.hpp

#ifndef _TurtleBrainsUnstable_InputAction_hpp
#define _TurtleBrainsUnstable_InputAction_hpp

#include <turtle_brains/application/tb_application_input.hpp>
#include <turtle_brains/system/unstable/tbu_input_device_manager.hpp>
#include <turtle_brains/math/tb_vector.hpp>

#include <memory>

namespace tbImplementation
{
    class InputActionData;
};

namespace TurtleBrains
{
    namespace Game
    {
        namespace Input
        {
            bool IsKeyPressed(const tbApplication::Key& key);

            bool IsKeyReleased(const tbApplication::Key& key);

            bool IsKeyDown(const tbApplication::Key& key);

            void GetMousePosition(int* mouseX, int* mouseY);

            tbMath::Vector2 GetMousePosition(void);

            bool GetMouseMovement(int* mouseX, int* mouseY);

            tbMath::Vector2 GetMouseMovement(void);

            void SetMousePosition(int mouseX, int mouseY);

            void SetMousePosition(const tbMath::Vector2& mousePosition);
        };

        class InputSignalConverterInterface
        {
        public:
            InputSignalConverterInterface(void) { }

            virtual ~InputSignalConverterInterface(void) { }

            virtual float DigitalToAnalogConverter(bool digitalValue, float deltaTime) = 0;

            virtual bool AnalogToDigitalConverter(float analogValue, float deltaTime) = 0;

            virtual float AnalogToAnalogConverter(float analogValue, float deltaTime) = 0;

            virtual float InvertAnalogValue(float analogValue) { return 1.0f - analogValue; };
        };

        class InputAction
        {
        public:
            InputAction(void);

            explicit InputAction(const tbApplication::Key& keyBinding);

            InputAction(const InputAction& other);

            ~InputAction(void);

            bool IsDown(void) const;

            bool IsPressed(void) const;

            bool IsReleased(void) const;

            float GetAnalogValue(void) const;

            bool IsAnalog(void) const;

            bool IsDigital(void) const;

            void ClearBindings(void);

            void AddBinding(const tbApplication::Key& keyBinding);

            void AddBinding(const tbSystem::Unstable::DeviceHandle& deviceHandle, const tbSystem::Unstable::ButtonIdentifier& button);

            void AddAnalogBinding(const tbSystem::Unstable::DeviceHandle& deviceHandle, const tbSystem::Unstable::AxisIdentifier& axis, bool inverted = false);

            void RemoveBinding(const tbApplication::Key& keyBinding);

            void RemoveBinding(const tbSystem::Unstable::DeviceHandle& deviceHandle, const tbSystem::Unstable::ButtonIdentifier& button);

            void RemoveAnalogBinding(const tbSystem::Unstable::DeviceHandle& deviceHandle, const tbSystem::Unstable::AxisIdentifier& axis);

            void SetInputSignalConverter(InputSignalConverterInterface* signalConverter);

            InputAction& operator=(const InputAction& other);

        private:
            std::unique_ptr<tbImplementation::InputActionData> mData;
        };

    }; /* namespace Game */
}; /* namespace TurtleBrains */

namespace tbGame = TurtleBrains::Game;

#endif /* _TurtleBrainsUnstable_InputAction_hpp */