doc/api/_gx_handle_8h_source.html

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

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

#pragma once


#if GX_DEVELOP


GX_CORE_NAMESPACE_BEGIN()


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

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

class GxHandle : public GxClassBase

{

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

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

public:

    // RTTI定義

    GX_RTTI_ABSTRACT_CLASS(GxHandle, GxClassBase)

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

    GX_PROHIBIT_CLASS_BASE( GxHandle )


    // new, delete定義

    GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    enum class HANDLE_MODE

    {

        STATE,

        TRANSLATE,

        ROTATE,

        SCALE,

        MAX,

    };

#if GX_DEVELOP

    GX_ENUM_TABLE_MAX(HANDLE_MODE)

#endif //GX_DEVELOP


    enum HANDLE_TYPE_FLAG

    {

        HANDLE_TYPE_STATE       = 0,

        HANDLE_TYPE_TRANSLATE   = 0x01 << 0,

        HANDLE_TYPE_ROTATE      = 0x01 << 1,

        HANDLE_TYPE_SCALE       = 0x01 << 2,


        HANDLE_TYPE_ALL     = HANDLE_TYPE_TRANSLATE | HANDLE_TYPE_ROTATE | HANDLE_TYPE_SCALE,

    };


    enum class HANDLE_RESULT

    {

        EXIT,

        WAIT,

        MANIPULATE,

    };


    static const GxVector3 BOX_EXTENT;

    static const f32 AXIS_LENGTH;


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

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

    class GxUiBase : public GxClassBase

    {

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

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

    public:

        // RTTI定義

        GX_RTTI_ABSTRACT_CLASS(GxUiBase, GxClassBase)

        // new, delete定義

        GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)

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

        GX_PROHIBIT_CLASS_BASE(GxUiBase)


        enum class STATE

        {

            WAITING,

            MANIPULATING,

            MAX,

        };

#if GX_DEVELOP

        GX_ENUM_TABLE_MAX(STATE)

#endif //GX_DEVELOP


        enum class AXIS_TYPE

        {

            X = 0,

            Y,

            _2D_MAX,

            Z = _2D_MAX,

            _3D_MAX,

            ALL = _3D_MAX,

            SELECT_MAX,

            EYE = SELECT_MAX,

            NONE,

            MAX,

        };

#if GX_DEVELOP

        GX_ENUM_TABLE_MAX(AXIS_TYPE)

#endif //GX_DEVELOP


        static const GxColor COLOR_AXIS_X_HIGHLIGHT;

        static const GxColor COLOR_AXIS_Y_HIGHLIGHT;

        static const GxColor COLOR_AXIS_Z_HIGHLIGHT;

        static const GxColor COLOR_AXIS_ALL;

        static const GxColor COLOR_AXIS_ALL_HIGHLIGHT;

        static const GxColor COLOR_AXIS_SELECTED;

        static const GxColor COLOR_AXIS_EYE;

        static const GxColor COLOR_AXIS_EYE_HIGHLIGHT;

        static const GxColor COLOR_AXIS_OLD;


        static const GxPrimitiveMaterial MATERIAL[2];


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

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


        GxUiBase(GxHandle* pHandle);


        ~GxUiBase(void) override;


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

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

    public:

        virtual GxHandle::HANDLE_RESULT update(void);


        virtual void render(void);


        constexpr void resetState(void) { _state = STATE::WAITING; _manipulatingAxis = AXIS_TYPE::NONE; }


        virtual void addPropertyTable(GxPropertyTable& propertyTable);


    protected:

        GX_FORCE_INLINE GxMatrixAffine getParentWorldMatrix(void) const { return _pParentWorldMatrixAffine ? *_pParentWorldMatrixAffine : (_pParentWorldMatrix ? GxMatrixAffine(*_pParentWorldMatrix) : GxMatrixAffine::IDENTITY); }


    public:

        GxMatrixAffine getWorldMatrix(void) const;

    protected:


        GxVector3 getHandlingPlaneNormal(const GxMatrixAffine& matrix) const;


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

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

    public:

        virtual void setParam43(GxVector3* pOffset, GxQuaternion* pQuaternion, GxVector3* pScale, const GxMatrixAffine* pParentWorldMatrix, GxUnit2DBase* pUnit2D);

        virtual void setParam44(GxVector3* pOffset, GxQuaternion* pQuaternion, GxVector3* pScale, const GxMatrix44* pParentWorldMatrix, GxUnit2DBase* pUnit2D);

        constexpr GxVector3* getControlOffset(void) const { return _pOffset; }

        constexpr GxQuaternion* getControlQuaternion(void) const { return _pQuaternion; }

        constexpr GxVector3* getControlScale(void) const { return _pScale; }

        GX_FORCE_INLINE b32 isOnMouse(void) const { return _axisUnderMouse != AXIS_TYPE::NONE; }


        constexpr void setAxisDrawLength(const f32 length) { _axisDrawLength = length; }


        b32 isHitRect( const GxVector2& size, const GxVector2& centerPosition, f32 rotate, const GxVector2& mousePosition ) const;


    protected:

        constexpr void setState(STATE state) { _state = state; }

        constexpr STATE getState(void) const { return _state; }

        constexpr void setManipulatingAxis(AXIS_TYPE axis) { _manipulatingAxis = axis; }

        constexpr AXIS_TYPE getManipulatingAxis(void) { return _manipulatingAxis; }

        GX_FORCE_INLINE b32 is3D(void) const { return !_pHandle->_is2D; }


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

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

    protected:

        GxVector3*      _pOffset;

        GxQuaternion*   _pQuaternion;

        GxVector3*      _pScale;

        GxUnit2DBase*   _pUnit2D;

        // 以下の２つは排他とする

        const GxMatrixAffine* _pParentWorldMatrixAffine;

        const GxMatrix44* _pParentWorldMatrix;


        AXIS_TYPE   _axisUnderMouse;

        f32         _axisDrawLength;


    private:

        STATE       _state;

        AXIS_TYPE   _manipulatingAxis;

        GxHandle*   _pHandle;


    };


private:

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

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

    class GxUiTranslate : public GxUiBase

    {

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

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

    public:

        // RTTI定義

        GX_RTTI_ABSTRACT_CLASS(GxUiTranslate, GxUiBase)

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

        GX_PROHIBIT_CLASS_BASE(GxUiTranslate)


        static const GxVector3 DEFAULT_STEP;

        static const GxVector3 DEFAULT_SNAP;

        static const f32 RAY_CHECK_LENGTH;


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

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


        GxUiTranslate(GxHandle* pHandle);


        ~GxUiTranslate(void) override;


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

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

    public:

        GxHandle::HANDLE_RESULT update(void) override;


        void render(void) override;


        void addPropertyTable(GxPropertyTable& propertyTable) override;


        GX_FORCE_INLINE GxVector3 getOffset(void) const { return _addVector; }


        GX_FORCE_INLINE void setLocal(b32 isLocal) { _localFlag = isLocal; }


    protected:

        AXIS_TYPE getAxisUnderMouse(void);


        void eventTraceBackGroundOn(void);

        void eventTraceBackGroundOff(void);

        void eventPositionInitializeZero(void);

        void eventHitBackGroundPlusX(void);

        void eventHitBackGroundMinusX(void);

        void eventHitBackGroundPlusY(void);

        void eventHitBackGroundMinusY(void);

        void eventHitBackGroundPlusZ(void);

        void eventHitBackGroundMinusZ(void);


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

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

    private:

        GxVector3   _dragWorldPosition;

        GxVector3   _handlingPlaneNormal;

        GxVector3   _dragOffset;

        GxVector3   _addVector;


        b32         _isHitBackGround;


        b32         _isUseStep;

        GxVector3   _step;

        b32         _isUseSnap;

        GxVector3   _snap;


        b32         _localFlag;


    };


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

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

    class GxUiRotate : public GxUiBase

    {

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

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

    public:

        // RTTI定義

        GX_RTTI_ABSTRACT_CLASS(GxUiRotate, GxUiBase)

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

        GX_PROHIBIT_CLASS_BASE(GxUiRotate)


        static const f32 RADIUS_RATIO_AXIS_EYE;

        static const f32 RADIUS_RATIO_AXIS_ALL;

        static constexpr u32 CIRCLE_DIVIDE = 20;


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

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


        GxUiRotate(GxHandle* pHandle);


        ~GxUiRotate(void) override;


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

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

    public:

        static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);


        GxHandle::HANDLE_RESULT update(void) override;


        void render(void) override;


        GX_FORCE_INLINE GxQuaternion getOffset(void) const { return _addQuaternion; }


    protected:

        // note:未完成

        AXIS_TYPE getAxisUnderMouse(void);


        b32 checkHitCircleSegment(const GxVector3& rayStart, const GxVector3& rayEnd, const GxVector3& center, const GxVector3& axis, const f32 radius, GxVector3& hitPosition);


        void updateAxis(void);


        void addPropertyTable(GxPropertyTable& propertyTable) override;


        void eventRotateInitializeIdentity(void);


    private:

        // note:長いのでサブルーチン化した

        // note:未完成

        GxVector3 getDirectionCenterToMouse(const AXIS_TYPE type);


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

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

    public:

        void setParam43(GxVector3* pOffset, GxQuaternion* pQuaternion, GxVector3* pScale, const GxMatrixAffine* pParentWorldMatrix, GxUnit2DBase* pUnit2D) override;

        void setParam44(GxVector3* pOffset, GxQuaternion* pQuaternion, GxVector3* pScale, const GxMatrix44* pParentWorldMatrix, GxUnit2DBase* pUnit2D) override;


        void setSelectAxis(b32 isSelectAxis, AXIS_TYPE type);


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

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

    private:

        GxVector3       _mouseWorldPosition;

        GxVector3       _dragDirection;

        GxVector3       _currentDirection;

        GxQuaternion    _dragQuaternion;

        GxVector3       _axis[static_cast<u32>(AXIS_TYPE::MAX)];

        f32             _incrementRadian;

        GxQuaternion    _addQuaternion;


        b32             _isUseStep;

        f32             _step;

        b32             _isUseSnap;

        f32             _snap;


        b32             _isSelectAxis;

        AXIS_TYPE       _selectAxis;


    };


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

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

    class GxUiScale : public GxUiBase

    {

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

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

    public:

        // RTTI定義

        GX_RTTI_ABSTRACT_CLASS(GxUiScale, GxUiBase)

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

        GX_PROHIBIT_CLASS_BASE(GxUiScale)


        static const f32 SCALE_MIN;

        static const f32 SCALE_MAX;


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

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


        GxUiScale(GxHandle* pHandle);


        ~GxUiScale(void) override;


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

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

    public:

        GxHandle::HANDLE_RESULT update(void) override;


        void render(void) override;


        GX_FORCE_INLINE GxVector3 getOffset(void) const { return _addVector; }


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

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

    protected:

        // 中央(-1.0) <-->ハンドル位置(0.0) <--> 1.0...

        f32 getGuiAxisNormalized(const GxPoint2& mousePosition, AXIS_TYPE axisType, f32 value);


        AXIS_TYPE getAxisUnderMouse(void);


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

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

    private:

        GxVector3       _dragWorldPosition;

        GxVector3       _handlingPlaneNormal;

        GxVector3       _dragScale;

        GxVector3       _dragGuiAdd;

        GxVector3       _addVector;

        b32             _isUseStep;

        f32             _step;

        b32             _isUseSnap;

        f32             _snap;


    };


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

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

public:

    GxHandle(void);


    void initialize( const u32 handleTypeFlag );


    ~GxHandle(void) override {}


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

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


    HANDLE_RESULT update( void );


    void render( void );


protected:

    void stretchSize(void);

    void shrinkSize(void);


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

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

public:

    void setIsEnable( b32 isEnable );

    GX_FORCE_INLINE void set2D( void ) { _is2D = true; }


    void setParam(GxVector3* pPosition, GxQuaternion* pQuaternion, GxVector3* pScale, const GxMatrixAffine* pParentWorldMatrix = nullptr, GxUnit2DBase* pUnit2D = nullptr);

    void setParam(GxVector3* pPosition, GxQuaternion* pQuaternion, GxVector3* pScale, const GxMatrix44* pParentWorldMatrix, GxUnit2DBase* pUnit2D = nullptr);


    void setMode( HANDLE_MODE mode );

    void setLocalTranslate(b32 isLocal);


    //< 操作できる回転軸を設定

    void setSelRotateAxis(b32 isSelAxis, GxUiBase::AXIS_TYPE type);


    GxMatrixAffine getWorldMatrix( void );


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

    constexpr HANDLE_MODE getMode( void ) const { return _mode; }

    GxVector3* getControlOffset( void );

    GxQuaternion* getControlQuaternion( void );

    GxVector3* getControlScale( void );

    void createMenu( const GxPoint2& position );

    b32 isOnMouse( void ) const;


    static f32  getFloor( f32 value, const f32 step );

    static GxMatrixAffine getUnScale(const GxMatrixAffine& inMatix);


    void    setAxisDrawLength( const f32 length );

    GX_FORCE_INLINE f32 getAxisDrawLength( void ) const { return _axisDrawLength; }


    GxVector3    getOffsetTranslate(void) const;

    GxQuaternion getOffsetRotate(void) const;

    GxVector3    getOffsetScale(void) const;


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

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

private:

    b32         _isEnable;

    b32         _isDisp;

    b32         _is2D;

    HANDLE_MODE _mode;

    HANDLE_MODE _baseMode;

    GxUiBase*   _pHandleUi[static_cast<s32>(HANDLE_MODE::MAX)];

    GxUiBase    _handleUiState;

    GxUiTranslate _handleUiTranslate;

    GxUiRotate  _handleUiRotate;

    GxUiScale   _handleUiScale;


    static f32  _axisDrawLength;


};


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

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

class GxHandleConfig : public GxClassBase

{

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

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

public:

    // RTTI定義

    GX_RTTI_CLASS(GxHandleConfig, GxClassBase)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


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

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


    GxHandleConfig(void);


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

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


    void loadJson(const GxJson::GxJsonNode& jsonNode);

    // コピー

    GxHandleConfig& operator = (const GxHandleConfig& value);

    // 参照を設定

    GX_FORCE_INLINE void set(GxHandleConfig& value) { *this = value; }

    // デフォルトにリセット

    void setDefault(void);


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

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


    f32                         _translateStep;

    f32                         _translateShiftStep;

    f32                         _rotateStep;

    f32                         _rotateShiftStep;

    f32                         _scaleStep;

    f32                         _scaleShiftStep;


};


GX_CORE_NAMESPACE_END()


#endif // GX_DEVELOP

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

OUTPUT_TYPE::MAX
@ MAX
定義数

GxTypedObject
void GxTypedObject
その他
Definition GxDefine.h:213

INIT::NONE
@ NONE
何もしない

INIT::IDENTITY
@ IDENTITY
基礎値で初期化

AXIS::X
@ X
X.

AXIS::Z
@ Z
Z.

AXIS::Y
@ Y
Y.

RENDER_VIEW::_3D_MAX
@ _3D_MAX
汎用的な3Dビューの最大

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

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

GxJson::GxJsonNode
JSON解析用ノード
Definition GxJson.h:108

GxProperty
プロパティクラス
Definition GxProperty.h:48

GxPropertyTable
プロパティテーブルクラス
Definition GxProperty.h:1641

GxRtti
実行時型情報クラス
Definition GxRtti.h:154

GxUnit2DBase
2D基礎ユニットクラス
Definition GxUnit2DBase.h:24

GxColor
色
Definition GxColor.h:21

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

GxMatrixAffine
アフィン変換行列(行優先)
Definition GxMatrix.h:330

GxPoint2
座標
Definition GxStruct.h:867

GxPrimitiveMaterial
プリミティブマテリアル
Definition GxPrimitive.h:103

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

GxVector2
2次元ベクトル
Definition GxVector.h:34

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

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