GController.h

#ifndef GCONTROLLER_H
#define GCONTROLLER_H

#include "../G_Core/GBroadcasting.h"
#include "../G_System/GControllerInputDefines.h"

namespace GW
{
    namespace SYSTEM
    {


#pragma pack(push, 1)

        /*
        *   If the corresponding event is an Input Event inputCode and inputValue will contain the input code and value 
        *   respectively for the detected input. If the corresponding event is an Connection event inputCode and inputValue will be 0. 
        *   isConnected will be 0 for false and 1 for true.
        *   
        */
        struct GCONTROLLER_EVENT_DATA
        {
            int controllerIndex; 
            int controllerID;    
            int inputCode;       
            float inputValue;    
            int isConnected;     
        };
#pragma pack(pop)

        enum GControllerEvents
        {
            CONTROLLERBUTTONVALUECHANGED,       
            CONTROLLERAXISVALUECHANGED,         
            CONTROLLERCONNECTED,                
            CONTROLLERDISCONNECTED              
        };

        enum GControllerDeadzoneTypes
        {
            DEADZONESQUARE, 
            DEADZONECIRCLE  
        };

        static const GUUIID GControllerUUIID = 
        {
            0xdff7eebf, 0xc333, 0x4606,{ 0x95, 0x0, 0xbd, 0xe0, 0x1c, 0xe7, 0xc1, 0xcb }
        };



        class GController : public CORE::GBroadcasting
        {
        public:
            /*
            *   Use an Inputcode to check the state of a button or axis on the controller
            *   at the selected index. If a button is being checked the _outState will be 0 for 
            *   up and 1 for down. If a axis is being checked the _outState will be between -1 and 1 inclusively.
            *
            *   \param [in] _controllerIndex The controller index to check
            *   \param [in] _inputCode The input code for the button/axis to check
            *   \param [out] _outState Is a reference to a float to store the state.
            *
            *   \retval SUCCESS The button/axis state was was successfully stored in the out-param
            *   \retval FAILURE No controller is connected at the chosen index.
            *   \retval INVALID_ARGUMENT Ether _controllerIndex is out of range or _inputCode is invaild. 
            */
            virtual GReturn GetState(int _controllerIndex, int _inputCode, float& _outState) = 0;

            /*
            *   \param [in] _controllerIndex The controller index to check.
            *   \param [out] _outIsConnected Is a reference to a bool to store whether a controller is at the index.
            *
            *   \retval SUCCESS The out-param was successfully filled out
            *   \retval INVALID_ARGUMENT _controllerIndex was out of range.
            */
            virtual GReturn IsConnected(int _controllerIndex, bool& _outIsConnected) = 0;

            /*
            *   The controllers will be stored in a constant array where the size of the array
            *   is the maxium amnout of supported controllers.
            *
            *   \param [out] _outMax is a reference to a int to store the max index.
            *
            *   \retval SUCCESS The max index was successfully stored in the out-param
            */
            virtual GReturn GetMaxIndex(int &_outMax) = 0;

            /*
            *   The number returned will be how many controllers are currently stored in the 
            *   controller array.
            *
            *   \param [out] _outConnectedCount is a reference to a int to store the count of connected controllers
            *
            *   \retval SUCCESS The count of connected controllers was successfully stored in the out-param
            */
            virtual GReturn GetNumConnected(int &_outConnectedCount) = 0;

            /*
            *   Default deadzone is _type = DEADZONESQUARE, _deadzonePercentage = .2f
            *
            *   \param [in] _type Specifies the dead zone calculation to be used.
            *   \param [in] _deadzonePercentage The size of the deadzone.
            *
            *   \retval SUCCESS The deadzone was set to the new parameters
            *   \retval INVALID_ARGUMENT _deadzonePercentage is invaild
            */
            virtual GReturn SetDeadZone(GControllerDeadzoneTypes _type, float _deadzonePercentage) = 0;

            /*
            *   This will not replace a currently running vibration, the previous vibration must end or be stopped first.
            *   Controllers have diffrent start up times and strengths this method does not account for this.
            *
            *   \param [in] _pan is a -1 to 1 ratio where -1 is full left motor, 1 is full right motor.
            *   \param [in] _duration In seconds how long the vibration will run.
            *   \param [in] _strength 0 to 1 ratio of how strong the vibration will be.
            *   \param [in] _controllerIndex The controller to vibrate.
            *
            *   \retval SUCCESS The vibration has been started in the selected controller.
            *   \retval INVALID_ARGUMENT One or more arguments are out of range.
            *   \retval FAILURE Controller is currently vibrating.
            *   \retval FEATURE_UNSUPPORTED Vibration for the current controller type is not supported.
            */
            virtual GReturn StartVibration(float _pan, float _duration, float _strength, unsigned int _controllerIndex) = 0;

            /*
            *   \param [in] _controllerIndex The controller index to check.
            *   \param [out] _outIsVibrating Is a reference to a bool to store whether a controller is vibrating.
            *
            *   \retval SUCCESS The out-param was successfully filled out
            *   \retval INVALID_ARGUMENT _controllerIndex was out of range.
            *   \retval FEATURE_UNSUPPORTED Vibration for the current controller type is not supported.
            */
            virtual GReturn IsVibrating(unsigned int _controllerIndex, bool& _outIsVibrating) = 0;

            /*
            *   \param [in] _controllerIndex The controller index to stop
            *
            *   \retval SUCCESS The virbration was stop
            *   \retval INVALID_ARGUMENT _controllerIndex was out of range.
            *   \retval REDUNDANT_OPERATION The controller was not vibrating. 
            *   \retval FEATURE_UNSUPPORTED Vibration for the current controller type is not supported.
            */
            virtual GReturn StopVirbration(unsigned int _controllerIndex) = 0;

            /*
            *   \retval SUCCESS All vibrations were stopped
            *   \retval FEATURE_UNSUPPORTED Vibration for the current controller type is not supported.
            */
            virtual GReturn StopAllVirbrations() = 0;
        
        }; //end GController class

        /*
        *   Initializes a handle to a GConntroller object of the type specified.
        *   Created GConntroller object will have its reference count initialized to one.
        *
        *   \param [in] _controllerType The type of Controller to be supported
        *   \param [out] _outController Will contain GConntroller object if successfully created.
        *
        *   \retval SUCCESS GConntroller was successfully created
        *   \retval FAILURE GConntroller was not created. _outController will be NULL.
        *   \retval INVALID_ARGUMENT _controllerType is invaild or GController is NULL.
        *   \retval FEATURE_UNSUPPORTED _controllerType is not currently supported. _outController will be NULL.
        */
        GATEWARE_EXPORT_IMPLICIT GReturn CreateGController(int _controllerType, GController** _outController);
    } // end of SYSTEM namespace
} // end of GW namespace
#endif