GameDevice.h

Go to the documentation of this file.

//Luke Lenhart, 2011
//See /docs/License.txt for details on how this code may be used.

#pragma once

#include "../base/Setup.h"

#if defined(MPMA_COMPILE_INPUT) && defined(ENABLE_GAME_DEVICE_INPUT)

#include "../base/Types.h"

#include <string>
#include <list>
#include <vector>

namespace INPUT
{
    namespace GAME
    {
        class Device;
    }
}

namespace INPUT_INTERNAL
{
    struct PlatformDeviceData;
    struct PlatformObjectInformation;
    struct PlatformAxesInformation;

#if defined(_WIN32) || defined(_WIN64)
    //windows treats hats differently, so we need to track them internally separately
    class Hat
    {
    public:
        const std::string& GetName() const;
        const std::string& GetXName() const;
        const std::string& GetYName() const;
        const std::string& GetZName() const;
        bool IsPressed() const;
        float GetRotation() const; //0 to 2*PI

        Hat(INPUT_INTERNAL::PlatformObjectInformation *objectInfo);
        Hat(Hat &&o);
        ~Hat();

    private:
        INPUT_INTERNAL::PlatformObjectInformation *info;
        std::string nameX;
        std::string nameY;
        std::string nameZ;
        bool isPressed;
        float value;

        Hat(const Hat &o); //not implemented
        void SetState(char *rawdata);

        friend class INPUT::GAME::Device;
    };
#endif
}

namespace INPUT
{
    namespace GAME
    {
        class AxisSet
        {
        public:
            const std::string GetCombinedName() const;
            const std::string& GetPersistentIdentifier() const;

            bool IsXPresent() const; 
            bool IsYPresent() const; 
            bool IsZPresent() const; 
            const std::string& GetXName() const; 
            const std::string& GetYName() const; 
            const std::string& GetZName() const; 
            float GetXValue() const; 
            float GetYValue() const; 
            float GetZValue() const; 

            void SetXDeadZone(float amount); 
            void SetYDeadZone(float amount); 
            void SetZDeadZone(float amount); 
            float GetXDeadZone() const; 
            float GetYDeadZone() const; 
            float GetZDeadZone() const; 

            const Device* GetDevice() const;

            AxisSet(INPUT_INTERNAL::PlatformAxesInformation *objectInfo, Device *device);
            AxisSet(AxisSet &&o);
            ~AxisSet();

        private:
            std::string persistentIdentifier;
            INPUT_INTERNAL::PlatformAxesInformation *info;
            float xValue, yValue, zValue;
            float xDead, yDead, zDead;
            Device *parentDevice;

            AxisSet(const AxisSet &o); //not implemented
            void SetState(char *rawdata);
            void NormalizeMaximum();

            float ApplyDeadZone(float val, float dead);

            friend class Device;
        };

        class Button
        {
        public:
            const std::string& GetName() const;
            const std::string& GetPersistentIdentifier() const;
            bool IsPressed() const;
            const Device* GetDevice() const;

            //the application is not expected to use these directly
            Button(INPUT_INTERNAL::PlatformObjectInformation *objectInfo, Device *device);
            Button(Button &&o);
            ~Button();

        private:
            std::string persistentIdentifier;
            INPUT_INTERNAL::PlatformObjectInformation *info;
            bool isPressed;
            Device *parentDevice;

            Button(const Button &o); //not implemented
            void SetState(char *rawdata);

            friend class Device;
        };

        class Device
        {
        public:
            const std::string& GetName() const;
            const std::string& GetPersistentIdentifier() const;

            //Updates the data in all axes and buttons.  The application should not call this directly but should instead call PollAllDevices, which will also update global pressed states.
            void Poll();

            const std::list<AxisSet>& GetAxes() const;
            std::list<AxisSet>& GetAxes();
            const std::list<Button>& GetButtons() const;
            std::list<Button>& GetButtons();

            //the application is not expected to use these directly
            Device(INPUT_INTERNAL::PlatformDeviceData *platformData, const std::string &name, const std::string &persistentId);
            Device(Device &&o);
            ~Device();

#if defined(linux)
            //linux joy api doesn't provide relations between a device's axes.  MPMA will autodetect based on a known list, but this API allows apps to override the default layout for other devices
            struct AxisSetMap
            {
                inline AxisSetMap(): XNumber(-1), YNumber(-1), ZNumber(-1) {}

                std::string Name;
                int XNumber;
                int YNumber;
                int ZNumber;
            };

            //retrieves the current axis map
            const std::vector<AxisSetMap>& GetAxitMaps() const;

            //replaces the current axes map.  note that this frees all existing Axes on the device, so callers should beware any pointers they might have.
            void SetAxitMaps(const std::vector<AxisSetMap> &maps);

            //retrieves the number of device axes
            int GetAxisCount() const;
#endif

        private:
            std::string friendlyName;
            std::string persistentIdentifier;
            INPUT_INTERNAL::PlatformDeviceData *data;
            std::list<AxisSet> axes;
            std::list<Button> buttons;

#if defined(_WIN32) || defined(_WIN64)
            //hats are tracked internally separately on windows
            std::list<INPUT_INTERNAL::Hat> hats;
#elif defined(linux)
            std::vector<AxisSetMap> axisMaps;
#endif

            Device(const Device &o); //do not use
        };


        std::list<Device>& GetDevices();

        void EnableAutoPoll(bool enable);

        void PollAllDevices();

        const std::vector<const Button*>& GetCurrentlyPressedButtons();

        const std::vector<const Button*>& GetNewlyPressedButtons();

        const std::vector<const AxisSet*>& GetCurrentlyPressedAxes();

        const std::vector<const AxisSet*>& GetNewlyPressedAxes();

        Device* FindDevice(const std::string &identifierToFind);

        Button* FindButton(const std::string &identifierToFind);

        AxisSet* FindAxisSet(const std::string &identifierToFind);
    }
}

#endif //#if defined(MPMA_COMPILE_INPUT) && defined(ENABLE_GAME_DEVICE_INPUT)