doc/api/_gx_input_pad_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


#if defined(_WINDOWS)

#pragma warning ( disable:4668)

#endif //_WINDOWS


GX_CORE_NAMESPACE_BEGIN()


class GxUnitLocate;

class GxPadRecorder;

class GxResPadRecorder;

//===========================================================================

//===========================================================================


class GxPad : public GxInputDevice

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_ABSTRACT_CLASS(GxPad, GxInputDevice)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxPad)


    enum class TOUCH_PANEL

    {

        FRONT = 0,

        MAX,

    };


    class GxTouch;

    class GxMotion;


    class GxVibration;


    // ボタン定義                                         PS4/PSP2   | XBOX

    static constexpr u32 BUTTON_NULL    = 0;

    static constexpr u32 SELECT         = (1 << 0);

    static constexpr u32 START          = (1 << 1);

    static constexpr u32 LEFT_UP        = (1 << 2);

    static constexpr u32 LEFT_RIGHT     = (1 << 3);

    static constexpr u32 LEFT_DOWN      = (1 << 4);

    static constexpr u32 LEFT_LEFT      = (1 << 5);

    static constexpr u32 RIGHT_UP       = (1 << 6);

    static constexpr u32 RIGHT_RIGHT    = (1 << 7);

    static constexpr u32 RIGHT_DOWN     = (1 << 8);

    static constexpr u32 RIGHT_LEFT     = (1 << 9);

    static constexpr u32 LEFT_1         = (1 << 10);

    static constexpr u32 RIGHT_1        = (1 << 11);

    static constexpr u32 LEFT_2         = (1 << 12);

    static constexpr u32 RIGHT_2        = (1 << 13);

    static constexpr u32 LEFT_3         = (1 << 14);

    static constexpr u32 RIGHT_3        = (1 << 15);


    //  アナログスティック定義

    static constexpr u32 STICK_LEFT_UP      = (1 << 16);

    static constexpr u32 STICK_LEFT_RIGHT   = (1 << 17);

    static constexpr u32 STICK_LEFT_DOWN    = (1 << 18);

    static constexpr u32 STICK_LEFT_LEFT    = (1 << 19);

    static constexpr u32 STICK_RIGHT_UP     = (1 << 20);

    static constexpr u32 STICK_RIGHT_RIGHT  = (1 << 21);

    static constexpr u32 STICK_RIGHT_DOWN   = (1 << 22);

    static constexpr u32 STICK_RIGHT_LEFT   = (1 << 23);


    // 決定/キャンセルボタン定義

    static constexpr u32 OK =       (1 << 24);

    static constexpr u32 CANCEL =   (1 << 25);


    // NX

    static constexpr u32 MINUS_NX       = (1 << 0);

    static constexpr u32 PLUS_NX        = (1 << 1);

    static constexpr u32 LEFT_SL_NX     = (1 << 26);

    static constexpr u32 LEFT_SR_NX     = (1 << 27);

    static constexpr u32 RIGHT_SL_NX    = (1 << 28);

    static constexpr u32 RIGHT_SR_NX    = (1 << 29);


    // アナログスティック軸定義

    static constexpr u32 STICK_LEFT_AXIS_X  = 0;

    static constexpr u32 STICK_LEFT_AXIS_Y  = 1;

    static constexpr u32 STICK_RIGHT_AXIS_X = 2;

    static constexpr u32 STICK_RIGHT_AXIS_Y = 3;


    // 全てのボタン定義

    static constexpr u32 BUTTON_ALL = 0xFFFFFFFF;

    // 物理ボタン最大数

    static constexpr u32 PHISICAL_BUTTON_MAX = 24;

    // ボタン最大数

    static constexpr u32 BUTTON_MAX = 26;

    // アナログスティックの最大値

    static constexpr s32 STICK_VALUE_MAX = 32767;

    // アナログスティックの最小値

    static constexpr s32 STICK_VALUE_MIN = -32768;

    // アナログトリガーの最大値

    static constexpr u32 TRIGGER_VALUE_MAX = 255;


    enum class PAD_RECORDER

    {

        STOP = 0,

        RECORD,

        PLAY,

    };


    struct GxInputData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_RTTI_STRUCT(GxInputData);


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_FORCE_INLINE void clear(void){ GX_MEMSET(this, 0, sizeof(GxInputData)); }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        u32 _on;

        s32 _stickLeftX;

        s32 _stickLeftY;

        s32 _stickRightX;

        s32 _stickRightY;

        u8 _triggerLeft;

        u8 _triggerRight;


    };


    struct GxSaveData

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxInputData _inputData;

        u32 _old;

        u32 _oldTemporary;

        s32 _repeatCount[BUTTON_MAX];

        u32 _trigger;

        u32 _release;

        u32 _change;

        u32 _repeat;


    };


    struct GxMarginData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_RTTI_STRUCT(GxMarginData)


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxMarginData(void);


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        s32 _stickLeftX;

        s32 _stickLeftY;

        s32 _stickRightX;

        s32 _stickRightY;

        u8 _triggerLeft;

        u8 _triggerRight;


        s32 _stickLeftAnalogX;

        s32 _stickLeftAnalogY;

        s32 _stickRightAnalogX;

        s32 _stickRightAnalogY;

        u8 _triggerLeftAnalog;

        u8 _triggerRightAnalog;


        s32 _stickLeftClipX;

        s32 _stickLeftClipY;

        s32 _stickRightClipX;

        s32 _stickRightClipY;

        u8 _triggerLeftClip;

        u8 _triggerRightClip;


    };


#if defined(_PS4) || defined(_PS5)

    struct GxTrackerData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_STRUCT(GxTrackerData)


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxTrackerData(void){ clear(); }

        GX_FORCE_INLINE void clear(void){ _poseMatrix = GxMatrix44::IDENTITY; }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxMatrix44          _poseMatrix;


    };

#endif // _PS4


    GX_FORCE_INLINE static s32 RatioToStick(f32 ratio) { return static_cast<s32>(static_cast<f32>(STICK_VALUE_MAX) * ratio); }

    GX_FORCE_INLINE static s32 RatioToTrigger(f32 ratio) { return static_cast<s32>(static_cast<f32>(TRIGGER_VALUE_MAX) * ratio); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxPad(void);

    ~GxPad(void) override;

    b32 initialize(void) override;

    void clear(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    void getInputDataDevice(void) override;

    void update(void) override;

#if GX_DEVELOP

    void startRecord(void);

#endif //GX_DEVELOP

    void startPlay(void);

    void stopPadRecorder(void);

    void saveInput(void) override;

    void loadInput(void) override;

#if GX_DEVELOP

    void developRender(void) override {}

protected:

    void developRenderButton(const GxPoint2& position);

    GX_FORCE_INLINE void getRatioStickLeftXProperty(void* const pValue) const { *static_cast<f32*>(pValue) = getRatioStickLeftX(); }

    GX_FORCE_INLINE void getRatioStickLeftYProperty(void* const pValue) const { *static_cast<f32*>(pValue) = getRatioStickLeftY(); }

    GX_FORCE_INLINE void getRatioStickRightXProperty(void* const pValue) const { *static_cast<f32*>(pValue) = getRatioStickRightX(); }

    GX_FORCE_INLINE void getRatioStickRightYProperty(void* const pValue) const { *static_cast<f32*>(pValue) = getRatioStickRightY(); }

    GX_FORCE_INLINE void getRatioTriggerLeftProperty(void* const pValue) const { *static_cast<f32*>(pValue) = getRatioTriggerLeft(); }

    GX_FORCE_INLINE void getRatioTriggerRightProperty(void* const pValue) const { *static_cast<f32*>(pValue) = getRatioTriggerRight(); }

#endif //GX_DEVELOP

protected:

    virtual void updateTouch(void);

    virtual void updateMotion(void);

    virtual void updateVibration(void);

private:

    void loadResourceRecorder(PAD_RECORDER padRecorder);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_FORCE_INLINE const GxInputData& getInputData(void) const { return _inputData; }

    GX_FORCE_INLINE void setInputData(const GxInputData& inputData){ GX_MEMCPY(&_inputData, &inputData, sizeof(GxInputData)); }


    GX_FORCE_INLINE s32 getStickLeftX(void) const { return _inputData._stickLeftX; }

    GX_FORCE_INLINE s32 getStickLeftY(void) const { return _inputData._stickLeftY; }

    GX_FORCE_INLINE s32 getStickRightX(void) const { return _inputData._stickRightX; }

    GX_FORCE_INLINE s32 getStickRightY(void) const { return _inputData._stickRightY; }

    GX_FORCE_INLINE u8 getTriggerLeft(void) const { return _inputData._triggerLeft; }

    GX_FORCE_INLINE u8 getTriggerRight(void) const { return _inputData._triggerRight; }


    GX_FORCE_INLINE b32 isOn(u32 bit = BUTTON_ALL) const { return (_inputData._on & bit) ? true : false; }

    GX_FORCE_INLINE b32 isOld(u32 bit = BUTTON_ALL) const { return (_old & bit) ? true : false; }

    GX_FORCE_INLINE b32 isTrigger(u32 bit = BUTTON_ALL) const { return (_trigger & bit) ? true : false; }

    GX_FORCE_INLINE b32 isRelease(u32 bit = BUTTON_ALL) const { return (_release & bit) ? true : false; }

    GX_FORCE_INLINE b32 isChange(u32 bit = BUTTON_ALL) const { return (_change & bit) ? true : false; }

    GX_FORCE_INLINE b32 isRepeat(u32 bit = BUTTON_ALL) const { return (_repeat & bit) ? true : false; }


    // 互換性のため On/Off, アナログ, XY軸を同じ値で設定する

    constexpr void setMarginStickLeft(u32 margin){ _margin._stickLeftAnalogX = _margin._stickLeftAnalogY = _margin._stickLeftX = _margin._stickLeftY = static_cast<s32>(margin); }

    constexpr void setMarginStickRight(u32 margin){ _margin._stickRightAnalogX = _margin._stickRightAnalogY = _margin._stickRightX = _margin._stickRightY = static_cast<s32>(margin); }

    constexpr void setMarginTriggerLeft(u8 margin){ _margin._triggerLeftAnalog = _margin._triggerLeft = margin; }

    constexpr void setMarginTriggerRight(u8 margin){ _margin._triggerRightAnalog = _margin._triggerRight = margin; }


    constexpr void setMarginStickLeftOnOff(u32 marginX, u32 marginY){ _margin._stickLeftX = static_cast<s32>(marginX); _margin._stickLeftY = static_cast<s32>(marginY); }

    constexpr void setMarginStickRightOnOff(u32 marginX, u32 marginY){ _margin._stickRightX = static_cast<s32>(marginX); _margin._stickRightY = static_cast<s32>(marginY); }

    constexpr void setMarginTriggerLeftOnOff(u8 margin){ _margin._triggerLeft = margin; }

    constexpr void setMarginTriggerRightOnOff(u8 margin){ _margin._triggerRight = margin; }


    constexpr void setMarginStickLeftAnalog(u32 marginX, u32 marginY){ _margin._stickLeftAnalogX = static_cast<s32>(marginX); _margin._stickLeftAnalogY = static_cast<s32>(marginY); }

    constexpr void setMarginStickRightAnalog(u32 marginX, u32 marginY){ _margin._stickRightAnalogX = static_cast<s32>(marginX); _margin._stickRightAnalogY = static_cast<s32>(marginY); }

    constexpr void setMarginTriggerLeftAnalog(u8 margin){ _margin._triggerLeftAnalog = margin; }

    constexpr void setMarginTriggerRightAnalog(u8 margin){ _margin._triggerRightAnalog = margin; }


    constexpr void setMarginStickLeftClip(u32 clipX, u32 clipY){ _margin._stickLeftClipX = static_cast<s32>(clipX); _margin._stickLeftClipY = static_cast<s32>(clipY); }

    constexpr void setMarginStickRightClip(u32 clipX, u32 clipY){ _margin._stickRightClipX = static_cast<s32>(clipX); _margin._stickRightClipY = static_cast<s32>(clipY); }

    constexpr void setMarginTriggerLeftClip(u8 clip){ _margin._triggerLeftClip = clip; }

    constexpr void setMarginTriggerRightClip(u8 clip){ _margin._triggerRightClip = clip; }


    GX_FORCE_INLINE f32 getRatioStickLeftX(void) const { return getRatioStick(_inputData._stickLeftX, _margin._stickLeftAnalogX, _margin._stickLeftClipX); }

    GX_FORCE_INLINE f32 getRatioStickLeftY(void) const { return getRatioStick(_inputData._stickLeftY, _margin._stickLeftAnalogY, _margin._stickLeftClipY); }

    GX_FORCE_INLINE f32 getRatioStickRightX(void) const { return getRatioStick(_inputData._stickRightX, _margin._stickRightAnalogX, _margin._stickRightClipX); }

    GX_FORCE_INLINE f32 getRatioStickRightY(void) const { return getRatioStick(_inputData._stickRightY, _margin._stickRightAnalogY, _margin._stickRightClipY); }

    GX_FORCE_INLINE f32 getRatioTriggerLeft(void) const { return getRatioTrigger(_inputData._triggerLeft, _margin._triggerLeftAnalog, _margin._triggerLeftClip); }

    GX_FORCE_INLINE f32 getRatioTriggerRight(void) const { return getRatioTrigger(_inputData._triggerRight, _margin._triggerRightAnalog, _margin._triggerRightClip); }


    constexpr GxResPadRecorder* getResourcePadRecorder(void) const { return _pResourceRecorder; }

    constexpr PAD_RECORDER getPadRecorderStatus(void) const { return _recorderStatus; }

protected:

    void setResourcePadRecorder(GxResPadRecorder* pResource);

    f32 getRatioStick(s32 value, s32 margin, s32 clip = 0) const;

    f32 getRatioTrigger(s32 value, s32 margin, s32 clip = 0) const;

    GX_FORCE_INLINE b32 isOk(void) override { return isTrigger(OK); }

    GX_FORCE_INLINE b32 isCancel(void) override { return isTrigger(CANCEL); }

public:

    constexpr GxTouch* getTouch(TOUCH_PANEL panel) const { return _pTouch[static_cast<s32>(panel)]; }

    constexpr GxMotion* getMotion(void) const { return _pMotion; }


#if defined(_PS4)

    constexpr GxTrackerData* getTrackerData(void) const { return _pTrackerData; }

#endif // _PS4


    constexpr GxVibration* getVibration(void) const { return _pVibration; }


    constexpr GxUnitLocate* getUnit(void) const { return _pUnit; }

    constexpr void setUnit(GxUnitLocate* pUnit){ _pUnit = pUnit; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

protected:

    GxInputData _inputData;

    u32 _old;

    u32 _oldTemporary;


private:

    GxPadRecorder* _pRecorder;

    GxResPadRecorder* _pResourceRecorder;

    PAD_RECORDER _recorderStatus;

    s32 _repeatCount[BUTTON_MAX];

    u32 _trigger;

    u32 _release;

    u32 _change;

    u32 _repeat;

    GxMarginData _margin;

    GxSaveData _saveData;

    GxUnitLocate* _pUnit;


protected:

    GxVibration* _pVibration;

protected:

    GxTouch*  _pTouch[static_cast<s32>(TOUCH_PANEL::MAX)];

    GxMotion* _pMotion;

#if defined(_PS4) || defined(_PS5)

    GxTrackerData* _pTrackerData;

#endif // _PS4 || _PS5

};


//===========================================================================

//===========================================================================


class GxPad::GxVibration : public GxClassBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPad::GxVibration, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxVibration)


    enum class MOTOR

    {

        LEFT = 0,

        RIGHT,

        MAX,


        BIG = LEFT,

        SMALL = RIGHT,

    };


    class GxMotor : public GxClassBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_CLASS(GxMotor, GxClassBase)

        // GxClassBase継承クラス用禁止宣言

        GX_PROHIBIT_CLASS_BASE(GxMotor)


        class GxInformation : public GxClassBase

        {

            //-------------------------------------------------------------

            //-------------------------------------------------------------

        public:

            GX_RTTI_CLASS(GxInformation, GxClassBase)


            //-------------------------------------------------------------

            //-------------------------------------------------------------


            GxInformation(void) : _time(0.f), _power(0.f){}

            ~GxInformation(void) override {}

            const GxInformation& operator = (const GxInformation& information);


            //-------------------------------------------------------------

            //-------------------------------------------------------------


            f32 _time;

            f32 _power;

#if defined(_NX64)

            GxNativeInputVibration _vibration;

#endif // _NX64


        };


        static constexpr u32 VIBRATION_DATA_MAX = 16;

        static const f32 STOP_TIME;

        static const f32 INVALID_TIME;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxMotor(void);

        ~GxMotor(void) override {}


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        void update(void);

        void addRequest(f32 time, f32 power);


#if defined(_NX64)

        void addRequest(f32 time, const GxNativeInputVibration& value);

#endif // _NX64


        GX_FORCE_INLINE void stop(void){ addRequest(STOP_TIME, 0.0f); }


    private:

        void clear(void);


        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        constexpr f32 getPower(void) const { return _power; }


#if defined(_NX64)

        GX_FORCE_INLINE const GxNativeInputVibration& getValue(void) const { return _nativeVibration; }

#endif // _NX64


        //-------------------------------------------------------------

        //-------------------------------------------------------------

    private:

        GxInformation _vibration[VIBRATION_DATA_MAX];

        GxInformation _request[GxThread::HARDWARE_THREAD_MAX][VIBRATION_DATA_MAX];

        f32 _power;

#if defined(_NX64)

        GxNativeInputVibration _nativeVibration;

#endif // _NX64

    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxVibration(void);

    ~GxVibration(void) override {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void update(void);


#if defined(_NX64)

    void updateStyle(const GxNativePadId& padId);

    void apply(void);

#endif // _NX64


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxMotor* getMotor(MOTOR motor){ return &_motor[static_cast<s32>(motor)]; }


#if defined(_NX64)

    //  JoyConの形態が分かっていれば getMotor() を使用しても良い

    GxMotor* getMotorLeft(void);

    //  振動が１つしかない形態では getMotorLeft() と同じポインタを返す

    GxMotor* getMotorRight(void);

    constexpr u32 getHandleCount(void) const { return _handleCount; }

#endif // _NX64


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    GxMotor _motor[static_cast<s32>(MOTOR::MAX)];


#if defined(_NX64)

    GxNativeInputVibrationHandle    _handles[static_cast<s32>(MOTOR::MAX)];

    u32                             _handleCount;

#endif // _NX64


};


#if !defined(GX_TOUCH_POINT_MAX)

#define GX_TOUCH_POINT_MAX 6

#endif // !GX_TOUCH_POINT_MAX


//===========================================================================

//===========================================================================


class GxPad::GxTouch : public GxClassBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPad::GxTouch, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxTouch);


private:

#if defined(_PS4) || defined(_WINDOWS) || defined(_PS5)

    friend class GxPadPs4;


    struct GxTouchInformation : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_STRUCT(GxTouchInformation)


        struct GxTouchResolution : public GxStructBase

        {

            //-------------------------------------------------------------

            //-------------------------------------------------------------

        public:

            GX_RTTI_STRUCT(GxTouchResolution)


            //-------------------------------------------------------------

            //-------------------------------------------------------------


            u16     _x;

            u16     _y;


        };


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        f32     _pixelDensity;

        GxTouchResolution _resolution;


    };

#endif //_PS4 || _WINDOWS || _PS5


    struct GxTouchPointData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_STRUCT(GxTouchPointData)


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        s16 _x;

        s16 _y;


        //TODO:refactoring:move platform-specific code to sub-classes

#if defined(_PS4) || defined(_WINDOWS) || defined(_NX64) || defined(_PS5)

        u8 _id;

#endif //_PS4 || _WINDOWS || _NX64 || _PS5


    };


    struct GxTouchData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_STRUCT(GxTouchData)


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_FORCE_INLINE void clear(void){ GX_MEMSET(this, 0, sizeof(GxTouchData)); }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        u32 _positionCount;

        GxTouchPointData _point[GX_TOUCH_POINT_MAX];


    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxTouch(void);

    GxTouch(u32 panelNo);

    ~GxTouch(void) override {}

    void initialize(void);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void update(void);

private:

    void clear(void);

    void outputError(s32 error);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE b32 isEnable(void) const { return _enable; }

    void setEnable(b32 on);


    constexpr u32 getTouchCount(void) const { return _touchData._positionCount; }

    GX_FORCE_INLINE GxPoint2 getPoint(u32 pointNo) const { return GxPoint2(static_cast<s32>(_touchData._point[pointNo]._x), static_cast<s32>(_touchData._point[pointNo]._y)); }


#if defined(_PS4)  || defined(_WINDOWS) || defined(_PS5)

    constexpr s32 getHandle(void) const { return _handle; }

    constexpr void setHandle(s32 handle){ _handle = handle; }

    constexpr f32 getTouchPixelDensity(void) const { return _touchInformation._pixelDensity; }

    GX_FORCE_INLINE GxPoint2 getTouchResolution(void) const { return GxPoint2(_touchInformation._resolution._x, _touchInformation._resolution._y); }

#endif //_PS4 || _WINDOWS || _PS5

    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

#if defined(_PS4) || defined(_WINDOWS) || defined(_PS5)

    GxTouchInformation _touchInformation;

#endif //_PS4 || _WINDOWS || _PS5

    GxTouchData _touchData;

    b32 _enable;


#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5)

    s32 _handle;

#endif //_WINDOWS || _PS4 || _PS5

};


//===========================================================================

//===========================================================================


class GxPad::GxMotion : public GxClassBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPad::GxMotion, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxMotion);


private:

#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5)

    friend class GxPadPs4;

#elif defined(_NX64)

    friend class GxPadNX;

    static constexpr u32 SENSOR_HANDLE_COUNT_MAX = 2; // LR

#endif //_NX64


    struct GxLocationData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_STRUCT(GxLocationData)


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxVector3 _accelerometer;

        GxVector3 _gyro;


    };

    struct GxMotionData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_STRUCT(GxMotionData)


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_FORCE_INLINE void clear(void) { GX_MEMSET(this, 0, sizeof(GxMotionData)); }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxVector3 _acceleration;

        GxVector3 _angularVelocity;

        GxQuaternion _deviceQuaternion;

#if defined(_NX64)

        GxVector3 _angle;

#endif // _NX64


    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxMotion(void);

    ~GxMotion(void) override;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void update(void);

private:

    void outputError(s32 error);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE b32 isEnable(void) const { return _enable; }

    void setEnable(b32 on);


    GX_FORCE_INLINE const GxVector3& getAcceleration(void) const { return _motionData._acceleration; }

    GX_FORCE_INLINE const GxVector3& getAngularVelocity(void) const { return _motionData._angularVelocity; }

    GX_FORCE_INLINE const GxQuaternion& getRotationQuaternion(void) const { return _motionData._deviceQuaternion; }


#if defined(_NX64)

    GX_FORCE_INLINE const GxVector3& getAccelerationLeft(void) const { return _motionData._acceleration; }

    GX_FORCE_INLINE const GxVector3& getAngularVelocityLeft(void) const { return _motionData._angularVelocity; }

    GX_FORCE_INLINE const GxQuaternion& getRotationQuaternionLeft(void) const { return _motionData._deviceQuaternion; }

    GX_FORCE_INLINE const GxVector3& getAngleLeft(void) const { return _motionData._angle; }


    GX_FORCE_INLINE const GxVector3& getAccelerationRight(void) const { return _motionData2._acceleration; }

    GX_FORCE_INLINE const GxVector3& getAngularVelocityRight(void) const { return _motionData2._angularVelocity; }

    GX_FORCE_INLINE const GxQuaternion& getRotationQuaternionRight(void) const { return _motionData2._deviceQuaternion; }

    GX_FORCE_INLINE const GxVector3& getAngleRight(void) const { return _motionData2._angle; }


    constexpr u32 getHandleCount(void) const { return _handleCount; }

    const nn::hid::SixAxisSensorState* getSensorStateRawLeft(void) const;

    const nn::hid::SixAxisSensorState* getSensorStateRawRight(void) const;


private:

    void setSensorEnable(b32 on);

    void updateStyle(const GxNativePadId& padId);

#endif // _NX64


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    GxMotionData _motionData;

#if defined(_NX64)

    GxMotionData _motionData2;

    GxNativePadAxisState    _states[SENSOR_HANDLE_COUNT_MAX][GX_TOUCH_POINT_MAX];

    GxNativePadAxisHandle   _handles[SENSOR_HANDLE_COUNT_MAX];

    u32                     _handleCount;

#endif // _NX64


    b32 _enable;


};


#if defined(_WINDOWS) || defined(_XBOX_XS)

//===========================================================================

//===========================================================================

class GxPadXbox : public GxPad

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPadXbox, GxPad)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxPadXbox);

private:

    static constexpr s32 RETRY_WAIT_COUNT = 30;


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxPadXbox(void) : _enableFlag(false){}

    ~GxPadXbox(void) override {}

    b32 initialize(void) override;

    GX_FORCE_INLINE void clear(void) override { Super::clear(); }


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    void getInputDataDevice(void) override;

protected:

    void updateVibration(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_FORCE_INLINE b32 isEnable(void) const override { return _enableFlag; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    s32 _retryWaitCounter;

    b32 _enableFlag;


};

#endif //_WINDOWS || _XBOX_XS


#if defined(_WINDOWS) ||  defined(_PS4) || defined(_PS5)

//===========================================================================

//===========================================================================

class GxPadPs4 : public GxPad

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPadPs4, GxPad)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxPadPs4);


    friend class GxSysInput;


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxPadPs4(void);

    ~GxPadPs4(void) override {}

    b32 initialize(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

    void getInputDataDevice(void) override;


    static b32 loadPadFunctions(void);

    static void unloadPadFunctions(void);


protected:

    void updateVibration(void) override;


    void updateEnable(void);


    void updateRegistrationOfTracking(void);


    virtual void onChangeUserId(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // ユーザーIDは GxSysInput で管理される

    GX_FORCE_INLINE s32 getUserId(void) const override { return _userId; }

    void setUserId(s32 id) override;


    GX_FORCE_INLINE b32 isEnable(void) const override { return _isEnable; }

    GX_FORCE_INLINE virtual void setEnable(b32 isEnable) { _isEnable = isEnable; }


    GX_FORCE_INLINE virtual s32  getHandle(void) const { return _handle; }

    GX_FORCE_INLINE virtual void setHandle(s32 handle) { _handle = handle; }


    GX_FORCE_INLINE static b32  isUseVrTracker(void) { return _isUseVrTracker; }

    GX_FORCE_INLINE static void setUseVrTracker( b32 isUse ){ _isUseVrTracker = isUse; }


public:

    // (デフォルトは true でデッドゾーンは無反応)

    GX_FORCE_INLINE void setStickClamp(b32 enable) { _isStickClamp = enable; }

    //  デバイス固有の値は 0~255 の範囲で中心は 128 になります。

    constexpr u8 getStickDeadZoneLeft(void) const { return _deadZoneLeft; }

    //  デバイス固有の値は 0~255 の範囲で中心は 128 になります。

    constexpr u8 getStickDeadZoneRight(void) const { return _deadZoneRight; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    b32 _isStickClamp;

    u8  _deadZoneLeft;

    u8  _deadZoneRight;


    b32 _isEnable;

    s32 _handle;

    s32 _userId;


    static b32 _isUseVrTracker;


    b32 _isRegisteredToVrTracker;


};

#endif //_WINDOWS || _PS4 || _PS5


#if defined(_NX64)

//===========================================================================

//===========================================================================

class GxPadNX : public GxPad

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPadNX, GxPad)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxPadNX)


    enum class PAD_STYLE

    {

        UNKNOWN,

        FULLKEY,

        HANDHELD,

        HANDHELD_DUAL,

        DUAL,

        LEFT,

        RIGHT,

    };


    enum PAD_STYLE_MASK

    {

        PAD_STYLE_MASK_FULLKEY  = 0x01,

        PAD_STYLE_MASK_DUAL     = 0x02,

        PAD_STYLE_MASK_LEFT     = 0x04,

        PAD_STYLE_MASK_RIGHT    = 0x08,

    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxPadNX(void);

    ~GxPadNX(void) override {}

    b32 initialize(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    void updatePadColor(PAD_STYLE newStyle);


    void getInputDataDevice(void) override;


    void updateVibration(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_FORCE_INLINE b32 isEnable(void) const override { return _enableFlag; }

    constexpr GxNativePadId getNpadId(void) const { return _padId; }

    constexpr PAD_STYLE getStyle(void) const { return _style; }

    GX_FORCE_INLINE const GxColor& getMainColorLeft(void) const { return _mainColorL; }

    GX_FORCE_INLINE const GxColor& getSubColorLeft(void) const { return _subColorL; }

    GX_FORCE_INLINE const GxColor& getMainColorRight(void) const { return _mainColorR; }

    GX_FORCE_INLINE const GxColor& getSubColorRight(void) const { return _subColorR; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    b32                     _enableFlag;

    PAD_STYLE               _style;

    GxColor                 _mainColorL;

    GxColor                 _subColorL;

    GxColor                 _mainColorR;

    GxColor                 _subColorR;

    GxNativePadId           _padId;


};

#endif //_NX64


#if defined(_WINDOWS)

//===========================================================================

//===========================================================================

class GxPadPc : public GxPad

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPadPc, GxPad)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxPadPc);


    enum class TRIGGER_TYPE

    {

        DIGITAL,

        ANALOG,

    };


    struct GxRemapData : public GxStructBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        // RTTI

        GX_RTTI_STRUCT(GxRemapData)


        static constexpr u32 MAX_BUTTONS = 16;

        static constexpr u32 MAX_AXES = 4;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxRemapData(void) { initializeDefault(); }

        void initializeDefault(void);


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        void remap(GxPad::GxInputData& dstData, const DIJOYSTATE2& src) const;

        void swapButton(u32 buttonIdA, u32 buttonIdB);

        void swapStickAxis(u32 stickIdA, u32 stickIdB);

        void setStickReverse(b32 leftX, b32 leftY, b32 rightX, b32 rightY);

        void getStickReverse(b32* pLeftX, b32* pLeftY, b32* pRightX, b32* pRightY) const;

        void setStickOffset(s32 leftOffX, s32 leftOffY, s32 rightOffX, s32 rightOffY);

        void getStickOffset(s32* pLeftOffX, s32* pLeftOffY, s32* pRightOffX, s32* pRightOffY) const;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        s32 _stickLeftOffsetX;

        s32 _stickLeftOffsetY;

        s32 _stickRightOffsetX;

        s32 _stickRightOffsetY;

        s32 _stickLeftReverseX;

        s32 _stickLeftReverseY;

        s32 _stickRightReverseX;

        s32 _stickRightReverseY;

        u8 _remapButtons[MAX_BUTTONS];

        u8 _remapSticks[MAX_AXES];


    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxPadPc(void);

    ~GxPadPc(void) override;

    b32 initialize(void) override;

    GX_FORCE_INLINE void clear(void) override { Super::clear(); }


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    void getInputDataDevice(void) override;

private:

    static b32 isPadXbox(const GUID* pGuid);

    static BOOL CALLBACK enumDeviceCallback(const DIDEVICEINSTANCE* pDeviceInstance, void* pContext);

    static BOOL CALLBACK enumObjectsCallback(const DIDEVICEOBJECTINSTANCE* pDeviceObjectInstance, void* pContext);

    b32 createDirectInputDevice(void);

    void releaseDirectInputDevice(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_FORCE_INLINE b32 isEnable(void) const override { return _enableFlag; }

    constexpr IDirectInputDevice8* getDirectInputDevice(void) const { return _pDirectInputDevice; }

    constexpr u32 getNumButtons(void) const { return _numButtons; }

    constexpr u32 getNumPOVs(void) const { return _numPOVs; }

    constexpr u32 getNumAxes(void) const { return _numAxes; }

    GX_FORCE_INLINE const GxString& getProductGUID(void) const { return _productGUID; }

    GX_FORCE_INLINE const GxString& getProductName(void) const { return _productName; }

    GX_FORCE_INLINE GxRemapData* getRemapData(void) { return &_remapData; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    IDirectInputDevice8* _pDirectInputDevice;

    TRIGGER_TYPE _triggerType;

    b32 _enableFlag;

    u32 _numButtons;

    u32 _numPOVs;

    u32 _numAxes;

    GxString _productGUID;

    GxString _productName;


    // キャリブレーション関連

    GxRemapData _remapData;


};


#if GX_DEVELOP

//===========================================================================

//===========================================================================

class GxPadVirtual : public GxPad

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPadVirtual, GxPad)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxPadVirtual);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxPadVirtual(void){}

    ~GxPadVirtual(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    void getInputDataDevice(void) override;

    GX_FORCE_INLINE void developRender(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 isEnable(void) const override;


};

#endif //GX_DEVELOP

#endif //WINDOWS


//===========================================================================

//===========================================================================


class GxPadNetwork : public GxPad

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxPadNetwork, GxPad)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxPadNetwork)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxPadNetwork(void){}

    ~GxPadNetwork(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void getInputDataDevice(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE b32 isEnable(void) const override { return true; }


};


GX_CORE_NAMESPACE_END()

GX_PROHIBIT_CLASS_BASE
#define GX_PROHIBIT_CLASS_BASE(__CLASS__)
GxClassBase継承の禁止宣言
Definition GxBase.h:240

OUTPUT_TYPE::MAX
@ MAX
定義数

GX_TOUCH_POINT_MAX
#define GX_TOUCH_POINT_MAX
タッチの最大数
Definition GxInputPad.h:685

RENDER_FACE_CULLING_MODE::FRONT
@ FRONT
表をカリングする(右手系)

RENDER_INDEX_TYPE::UNKNOWN
@ UNKNOWN
未定義

GxClassBase
オブジェクト基底クラス
Definition GxBase.h:88

GxClassBaseRoot::operator=
constexpr GxClassBaseRoot & operator=(const GxClassBaseRoot &)
代入演算子
Definition GxBase.h:64

GxInputDevice
入力デバイスクラス
Definition GxSysInput.h:78

GxPad::GxMotion
モーションセンサークラス
Definition GxInputPad.h:886

GxPad::GxMotion::getRotationQuaternion
GX_FORCE_INLINE const GxQuaternion & getRotationQuaternion(void) const
回転を取得
Definition GxInputPad.h:999

GxPad::GxMotion::getAngularVelocity
GX_FORCE_INLINE const GxVector3 & getAngularVelocity(void) const
ジャイロの測定値を取得
Definition GxInputPad.h:997

GxPad::GxMotion::isEnable
GX_FORCE_INLINE b32 isEnable(void) const
有効判定
Definition GxInputPad.h:990

GxPad::GxMotion::getAcceleration
GX_FORCE_INLINE const GxVector3 & getAcceleration(void) const
加速度の測定値を取得
Definition GxInputPad.h:995

GxPad::GxTouch
タッチセンサークラス
Definition GxInputPad.h:692

GxPad::GxTouch::getTouchCount
constexpr u32 getTouchCount(void) const
タッチ数を取得
Definition GxInputPad.h:850

GxPad::GxTouch::getPoint
GX_FORCE_INLINE GxPoint2 getPoint(u32 pointNo) const
タッチ点を取得
Definition GxInputPad.h:852

GxPad::GxTouch::isEnable
GX_FORCE_INLINE b32 isEnable(void) const
有効判定
Definition GxInputPad.h:845

GxPad::GxTouch::~GxTouch
~GxTouch(void) override
デストラクタ
Definition GxInputPad.h:820

GxPad::GxVibration::GxMotor::GxInformation
情報
Definition GxInputPad.h:515

GxPad::GxVibration::GxMotor::GxInformation::_time
f32 _time
振動時間
Definition GxInputPad.h:542

GxPad::GxVibration::GxMotor::GxInformation::_power
f32 _power
振動値
Definition GxInputPad.h:543

GxPad::GxVibration::GxMotor::GxInformation::~GxInformation
~GxInformation(void) override
デストラクタ
Definition GxInputPad.h:532

GxPad::GxVibration::GxMotor
モータークラス
Definition GxInputPad.h:503

GxPad::GxVibration::GxMotor::getPower
constexpr f32 getPower(void) const
振動値を取得
Definition GxInputPad.h:598

GxPad::GxVibration::GxMotor::~GxMotor
~GxMotor(void) override
デストラクタ
Definition GxInputPad.h:566

GxPad::GxVibration::GxMotor::VIBRATION_DATA_MAX
static constexpr u32 VIBRATION_DATA_MAX
振動情報数
Definition GxInputPad.h:551

GxPad::GxVibration::GxMotor::INVALID_TIME
static const f32 INVALID_TIME
無効時間定義
Definition GxInputPad.h:555

GxPad::GxVibration::GxMotor::addRequest
void addRequest(f32 time, f32 power)
リクエストを追加
Definition GxInputPad.cpp:855

GxPad::GxVibration::GxMotor::GxMotor
GxMotor(void)
コンストラクタ
Definition GxInputPad.cpp:789

GxPad::GxVibration::GxMotor::STOP_TIME
static const f32 STOP_TIME
停止時間定義
Definition GxInputPad.h:553

GxPad::GxVibration::GxMotor::stop
GX_FORCE_INLINE void stop(void)
停止
Definition GxInputPad.h:585

GxPad::GxVibration::GxMotor::update
void update(void)
更新
Definition GxInputPad.cpp:798

GxPad::GxVibration
パッド振動クラス
Definition GxInputPad.h:480

GxPad::GxVibration::~GxVibration
~GxVibration(void) override
デストラクタ
Definition GxInputPad.h:629

GxPad::GxVibration::GxVibration
GxVibration(void)
コンストラクタ
Definition GxInputPad.cpp:680

GxPad::GxVibration::getMotor
GX_FORCE_INLINE GxMotor * getMotor(MOTOR motor)
モーター情報を取得
Definition GxInputPad.h:654

GxPad::GxVibration::MOTOR
MOTOR
振動モーター数
Definition GxInputPad.h:492

GxPad::GxVibration::MOTOR::RIGHT
@ RIGHT
右モーター

GxPad::GxVibration::MOTOR::MAX
@ MAX
モーター数

GxPad::GxVibration::MOTOR::LEFT
@ LEFT
左モーター

GxPad::GxVibration::MOTOR::SMALL
@ SMALL
小モーター

GxPad::GxVibration::MOTOR::BIG
@ BIG
大モーター

GxPad
パッドクラス
Definition GxInputPad.h:25

GxPad::getRatioStickRightY
GX_FORCE_INLINE f32 getRatioStickRightY(void) const
右スティックY軸のパッド入力比率取得 (-1.0～1.0, アナログ入力マージンが適用されます)
Definition GxInputPad.h:402

GxPad::_old
u32 _old
前フレームの押し状態
Definition GxInputPad.h:449

GxPad::getTriggerRight
GX_FORCE_INLINE u8 getTriggerRight(void) const
右トリガーの値取得 (マージンを適用しない値 0～TRIGGER_VALUE_MAX)
Definition GxInputPad.h:343

GxPad::setMarginTriggerRightAnalog
constexpr void setMarginTriggerRightAnalog(u8 margin)
右トリガーのアナログ入力マージンを設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:384

GxPad::setInputData
GX_FORCE_INLINE void setInputData(const GxInputData &inputData)
入力データの設定
Definition GxInputPad.h:330

GxPad::isRelease
GX_FORCE_INLINE b32 isRelease(u32 bit=BUTTON_ALL) const
放した瞬間判定
Definition GxInputPad.h:352

GxPad::setMarginStickLeftAnalog
constexpr void setMarginStickLeftAnalog(u32 marginX, u32 marginY)
左スティックのアナログ入力マージンを設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:378

GxPad::setMarginTriggerRightOnOff
constexpr void setMarginTriggerRightOnOff(u8 margin)
右トリガーの On/Off 判定しきい値を設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:375

GxPad::setUnit
constexpr void setUnit(GxUnitLocate *pUnit)
操作ユニットの設定
Definition GxInputPad.h:440

GxPad::setMarginTriggerLeftAnalog
constexpr void setMarginTriggerLeftAnalog(u8 margin)
左トリガーのアナログ入力マージンを設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:382

GxPad::getRatioStickLeftX
GX_FORCE_INLINE f32 getRatioStickLeftX(void) const
左スティックX軸のパッド入力比率取得 (-1.0～1.0, アナログ入力マージンが適用されます)
Definition GxInputPad.h:396

GxPad::setMarginStickRightClip
constexpr void setMarginStickRightClip(u32 clipX, u32 clipY)
右スティックのアナログ入力切り捨て値を設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:389

GxPad::getMotion
constexpr GxMotion * getMotion(void) const
モーションセンサー情報の取得
Definition GxInputPad.h:427

GxPad::setMarginTriggerLeftOnOff
constexpr void setMarginTriggerLeftOnOff(u8 margin)
左トリガーの On/Off 判定しきい値を設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:373

GxPad::isCancel
GX_FORCE_INLINE b32 isCancel(void) override
キャンセルボタンの判定
Definition GxInputPad.h:422

GxPad::setMarginStickLeftClip
constexpr void setMarginStickLeftClip(u32 clipX, u32 clipY)
左スティックのアナログ入力切り捨て値を設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:387

GxPad::getVibration
constexpr GxVibration * getVibration(void) const
振動情報の取得
Definition GxInputPad.h:435

GxPad::getTriggerLeft
GX_FORCE_INLINE u8 getTriggerLeft(void) const
左トリガーの値取得 (マージンを適用しない値 0～TRIGGER_VALUE_MAX)
Definition GxInputPad.h:341

GxPad::getStickRightY
GX_FORCE_INLINE s32 getStickRightY(void) const
右スティック縦の値取得 (マージンを適用しない値 STICK_VALUE_MIN～STICK_VALUE_MAX)
Definition GxInputPad.h:339

GxPad::setMarginStickRightOnOff
constexpr void setMarginStickRightOnOff(u32 marginX, u32 marginY)
右スティックの On/Off 判定しきい値を設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:371

GxPad::_inputData
GxInputData _inputData
入力データ
Definition GxInputPad.h:448

GxPad::getRatioStickRightX
GX_FORCE_INLINE f32 getRatioStickRightX(void) const
右スティックX軸のパッド入力比率取得 (-1.0～1.0, アナログ入力マージンが適用されます)
Definition GxInputPad.h:400

GxPad::setMarginStickRight
constexpr void setMarginStickRight(u32 margin)
右スティックの On/Off、アナログ入力マージンを設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:362

GxPad::_oldTemporary
u32 _oldTemporary
前フレーム用に保存しておく情報
Definition GxInputPad.h:450

GxPad::getResourcePadRecorder
constexpr GxResPadRecorder * getResourcePadRecorder(void) const
パッドレコーダーリソースの取得
Definition GxInputPad.h:409

GxPad::isOn
GX_FORCE_INLINE b32 isOn(u32 bit=BUTTON_ALL) const
押し状態判定
Definition GxInputPad.h:346

GxPad::setMarginTriggerRightClip
constexpr void setMarginTriggerRightClip(u8 clip)
右トリガーのアナログ入力切り捨て値を設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:393

GxPad::setMarginTriggerRight
constexpr void setMarginTriggerRight(u8 margin)
右トリガーの On/Off、アナログ入力マージンを設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:366

GxPad::isTrigger
GX_FORCE_INLINE b32 isTrigger(u32 bit=BUTTON_ALL) const
押した瞬間判定
Definition GxInputPad.h:350

GxPad::getTouch
constexpr GxTouch * getTouch(TOUCH_PANEL panel) const
タッチセンサー情報の取得
Definition GxInputPad.h:425

GxPad::getInputData
GX_FORCE_INLINE const GxInputData & getInputData(void) const
入力データの取得
Definition GxInputPad.h:328

GxPad::isOk
GX_FORCE_INLINE b32 isOk(void) override
決定ボタンの判定
Definition GxInputPad.h:420

GxPad::setMarginTriggerLeft
constexpr void setMarginTriggerLeft(u8 margin)
左トリガーの On/Off、アナログ入力マージンを設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:364

GxPad::RatioToTrigger
static GX_FORCE_INLINE s32 RatioToTrigger(f32 ratio)
Ratio からトリガー値へ変換する
Definition GxInputPad.h:252

GxPad::getRatioTriggerLeft
GX_FORCE_INLINE f32 getRatioTriggerLeft(void) const
左トリガーのパッド入力比率取得 (0.0～1.0, アナログ入力マージンが適用されます)
Definition GxInputPad.h:404

GxPad::getRatioTriggerRight
GX_FORCE_INLINE f32 getRatioTriggerRight(void) const
右トリガーのパッド入力比率取得 (0.0～1.0, アナログ入力マージンが適用されます)
Definition GxInputPad.h:406

GxPad::isOld
GX_FORCE_INLINE b32 isOld(u32 bit=BUTTON_ALL) const
前フレームの押し状態判定
Definition GxInputPad.h:348

GxPad::getPadRecorderStatus
constexpr PAD_RECORDER getPadRecorderStatus(void) const
パッドレコーダー状態の取得
Definition GxInputPad.h:411

GxPad::setMarginTriggerLeftClip
constexpr void setMarginTriggerLeftClip(u8 clip)
左トリガーのアナログ入力切り捨て値を設定 (0～TRIGGER_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:391

GxPad::getStickLeftY
GX_FORCE_INLINE s32 getStickLeftY(void) const
左スティック縦の値取得 (マージンを適用しない値 STICK_VALUE_MIN～STICK_VALUE_MAX)
Definition GxInputPad.h:335

GxPad::getRatioStickLeftY
GX_FORCE_INLINE f32 getRatioStickLeftY(void) const
左スティックY軸のパッド入力比率取得 (-1.0～1.0, アナログ入力マージンが適用されます)
Definition GxInputPad.h:398

GxPad::isRepeat
GX_FORCE_INLINE b32 isRepeat(u32 bit=BUTTON_ALL) const
リピート判定
Definition GxInputPad.h:356

GxPad::PAD_RECORDER
PAD_RECORDER
パッドレコーダーの状態
Definition GxInputPad.h:107

GxPad::setMarginStickLeft
constexpr void setMarginStickLeft(u32 margin)
左スティックの On/Off、アナログ入力マージンを設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:360

GxPad::_pMotion
GxMotion * _pMotion
モーションセンサー情報
Definition GxInputPad.h:469

GxPad::TOUCH_PANEL
TOUCH_PANEL
タッチパネル定義
Definition GxInputPad.h:37

GxPad::RatioToStick
static GX_FORCE_INLINE s32 RatioToStick(f32 ratio)
Ratio からスティック値へ変換する
Definition GxInputPad.h:250

GxPad::getStickRightX
GX_FORCE_INLINE s32 getStickRightX(void) const
右スティック横の値取得 (マージンを適用しない値 STICK_VALUE_MIN～STICK_VALUE_MAX)
Definition GxInputPad.h:337

GxPad::getStickLeftX
GX_FORCE_INLINE s32 getStickLeftX(void) const
左スティック横の値取得 (マージンを適用しない値 STICK_VALUE_MIN～STICK_VALUE_MAX)
Definition GxInputPad.h:333

GxPad::setMarginStickLeftOnOff
constexpr void setMarginStickLeftOnOff(u32 marginX, u32 marginY)
左スティックの On/Off 判定しきい値を設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:369

GxPad::_pVibration
GxVibration * _pVibration
振動情報
Definition GxInputPad.h:466

GxPad::setMarginStickRightAnalog
constexpr void setMarginStickRightAnalog(u32 marginX, u32 marginY)
右スティックのアナログ入力マージンを設定 (0～STICK_VALUE_MAX の範囲で指定)
Definition GxInputPad.h:380

GxPad::isChange
GX_FORCE_INLINE b32 isChange(u32 bit=BUTTON_ALL) const
On,Off変化判定
Definition GxInputPad.h:354

GxPad::getUnit
constexpr GxUnitLocate * getUnit(void) const
操作ユニットの取得
Definition GxInputPad.h:438

GxPadNetwork
ネットワークパッドクラス
Definition GxInputPad.h:1563

GxPadNetwork::~GxPadNetwork
~GxPadNetwork(void) override
デストラクタ
Definition GxInputPad.h:1582

GxPadNetwork::isEnable
GX_FORCE_INLINE b32 isEnable(void) const override
有効判定
Definition GxInputPad.h:1600

GxPadNetwork::getInputDataDevice
GX_FORCE_INLINE void getInputDataDevice(void) override
デバイスから入力を取得
Definition GxInputPad.h:1591

GxPadRecorder
入力パッドレコーダー処理クラス
Definition GxPadRecorder.h:21

GxResPadRecorder
入力パッドレコーダーリソースクラス
Definition GxResPadRecorder.h:19

GxSysInput
入力システムクラス
Definition GxSysInput.h:217

GxUnitLocate
座標ユニット基礎クラス
Definition GxUnitLocate.h:23

GxColor
色
Definition GxColor.h:21

GxMatrix44
4×4行列(行優先)
Definition GxMatrix.h:607

GxMatrix44::IDENTITY
static const GxMatrix44 IDENTITY
単位行列
Definition GxMatrix.h:618

GxPad::GxInputData
入力情報
Definition GxInputPad.h:114

GxPad::GxInputData::_stickRightY
s32 _stickRightY
右スティック縦
Definition GxInputPad.h:141

GxPad::GxInputData::clear
GX_FORCE_INLINE void clear(void)
クリア
Definition GxInputPad.h:129

GxPad::GxInputData::_stickLeftY
s32 _stickLeftY
左スティック縦
Definition GxInputPad.h:139

GxPad::GxInputData::_stickRightX
s32 _stickRightX
右スティック横
Definition GxInputPad.h:140

GxPad::GxInputData::_stickLeftX
s32 _stickLeftX
左スティック横(-32768 and 32767)
Definition GxInputPad.h:138

GxPad::GxInputData::_on
u32 _on
押し状態
Definition GxInputPad.h:137

GxPad::GxInputData::_triggerRight
u8 _triggerRight
右トリガー
Definition GxInputPad.h:143

GxPad::GxInputData::_triggerLeft
u8 _triggerLeft
左トリガー(0 and 255)
Definition GxInputPad.h:142

GxPad::GxMarginData
マージン関連
Definition GxInputPad.h:168

GxPad::GxMarginData::_stickLeftY
s32 _stickLeftY
左スティック Y軸 の On/Off 入力判定しきい値
Definition GxInputPad.h:192

GxPad::GxMarginData::_triggerLeft
u8 _triggerLeft
左トリガの On/Off 入力判定しきい値
Definition GxInputPad.h:195

GxPad::GxMarginData::_triggerLeftAnalog
u8 _triggerLeftAnalog
左トリガのアナログ入力マージン
Definition GxInputPad.h:202

GxPad::GxMarginData::_triggerRight
u8 _triggerRight
右トリガの On/Off 入力判定しきい値
Definition GxInputPad.h:196

GxPad::GxMarginData::_triggerLeftClip
u8 _triggerLeftClip
左トリガのアナログ入力切り捨て
Definition GxInputPad.h:209

GxPad::GxMarginData::_stickRightAnalogX
s32 _stickRightAnalogX
右スティック X軸 のアナログ入力マージン
Definition GxInputPad.h:200

GxPad::GxMarginData::_stickRightClipX
s32 _stickRightClipX
右スティック X軸 のアナログ入力切り捨て
Definition GxInputPad.h:207

GxPad::GxMarginData::_stickLeftClipX
s32 _stickLeftClipX
左スティック X軸 のアナログ入力切り捨て
Definition GxInputPad.h:205

GxPad::GxMarginData::_triggerRightClip
u8 _triggerRightClip
右トリガのアナログ入力切り捨て
Definition GxInputPad.h:210

GxPad::GxMarginData::_stickRightClipY
s32 _stickRightClipY
右スティック Y軸 のアナログ入力切り捨て
Definition GxInputPad.h:208

GxPad::GxMarginData::_stickRightAnalogY
s32 _stickRightAnalogY
右スティック Y軸 のアナログ入力マージン
Definition GxInputPad.h:201

GxPad::GxMarginData::_stickLeftAnalogY
s32 _stickLeftAnalogY
左スティック Y軸 のアナログ入力マージン
Definition GxInputPad.h:199

GxPad::GxMarginData::_stickLeftX
s32 _stickLeftX
左スティック X軸 の On/Off 入力判定しきい値
Definition GxInputPad.h:191

GxPad::GxMarginData::_stickRightY
s32 _stickRightY
右スティック Y軸 の On/Off 入力判定しきい値
Definition GxInputPad.h:194

GxPad::GxMarginData::_stickLeftAnalogX
s32 _stickLeftAnalogX
左スティック X軸 のアナログ入力マージン
Definition GxInputPad.h:198

GxPad::GxMarginData::_stickLeftClipY
s32 _stickLeftClipY
左スティック Y軸 のアナログ入力切り捨て
Definition GxInputPad.h:206

GxPad::GxMarginData::_triggerRightAnalog
u8 _triggerRightAnalog
右トリガのアナログ入力マージン
Definition GxInputPad.h:203

GxPad::GxMarginData::_stickRightX
s32 _stickRightX
右スティック X軸 の On/Off 入力判定しきい値
Definition GxInputPad.h:193

GxPad::GxSaveData
保存情報
Definition GxInputPad.h:149

GxPad::GxSaveData::_trigger
u32 _trigger
押した瞬間
Definition GxInputPad.h:159

GxPad::GxSaveData::_inputData
GxInputData _inputData
入力情報
Definition GxInputPad.h:155

GxPad::GxSaveData::_repeat
u32 _repeat
リピート
Definition GxInputPad.h:162

GxPad::GxSaveData::_old
u32 _old
前フレームの押し状態
Definition GxInputPad.h:156

GxPad::GxSaveData::_release
u32 _release
放した瞬間
Definition GxInputPad.h:160

GxPad::GxSaveData::_change
u32 _change
On,Off変化
Definition GxInputPad.h:161

GxPad::GxSaveData::_oldTemporary
u32 _oldTemporary
前フレーム用に保存しておく情報
Definition GxInputPad.h:157

GxPoint2
座標
Definition GxStruct.h:867

GxQuaternion
クォータニオン
Definition GxQuaternion.h:19

GxString
文字列型クラス
Definition GxString.h:18

GxStructBase
Definition GxBase.h:24

GxVector3
3次元ベクトル
Definition GxVector.h:245

b32
32bitブーリアン
Definition GxDefine.h:173