GxUnit2DBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
// 外部クラスの前方宣言
#if GX_DEVELOP
class GxHandle;
#endif // GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxUnit2DBase : public GxUnitBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS_NAME(GxUnit2DBase, GxUnitBase, "2D基礎")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnit2DBase)
 
    
    enum class LAYOUT
    {
        LEFT_TOP = 0,   
        LEFT_MIDDLE,    
        LEFT_BOTTOM,    
        MIDDLE_TOP,     
        MIDDLE_MIDDLE,  
        MIDDLE_BOTTOM,  
        RIGHT_TOP,      
        RIGHT_MIDDLE,   
        RIGHT_BOTTOM,   
        MAX,            
    };
    static const GxVector2 LAYOUTS[static_cast<u32>(LAYOUT::MAX)];
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(LAYOUT)
#endif //GX_DEVELOP
 
    enum class BLEND_TYPE
    {
        NONE = 0,       
        ADD,            
        COLOR_ADD,      
        SUB,            
        COLOR_SUB,      
        COLOR_MULTI,    
        COLOR_SCREEN,   
        OPAQUE_,        
        MAX,            
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(BLEND_TYPE)
#endif //GX_DEVELOP
 
    static const GxSize DEFAULT_SIZE;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxUnit2DBase(void);
 
    b32 setup(void) override;
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void preAsyncUpdate(void) override;
    void forceAsyncUpdate(void) override;
    void render(void) override;
 
#if GX_DEVELOP
    virtual void developRender(void);
#endif // GX_DEVELOP
 
    virtual b32 makeMaterial(GxPrimitiveMaterial& material, f32& zWritePosition) const;
    virtual void setMaterial(GxPrimitiveMaterial& material) const;
    virtual void renderPrimitive(const GxRectF& rect, f32 positionZ, f32 z, const GxPrimitiveMaterial& material, const GxVector2& rotateCenter);
 
public:
    void updateWorldMatrix(void);
 
    b32 isIncluding( const GxPoint2& mousePosition ) const;
 
private:
    void updatePriority(f32& childPriority);
    void searchUnit( GxArrayClassBase& searchList, GxUnitBase* pRootParent );
    void searchUnitSub( GxArrayClassBase& searchList, GxUnitBase* pUnit );
    b32 isFlipX(void) const;
    b32 isFlipY(void) const;
    void getWorldMatrix(GxMatrixAffine& matrix);
    void updateRect(void);
 
#if GX_DEVELOP
private:
    void controlHandle(void);
    void initializeHandlePosition(void);
    void initializeHandleQuaternion(void);
    void initializeHandleScale(void);
 
public:
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxSize& getSize(void) const { return _size; }
    GX_FORCE_INLINE void setSize(const GxSize& size) { _size = size; }
    GX_FORCE_INLINE const GxRectF& getRect(void) const { return _rect; }
    GX_FORCE_INLINE const GxMatrixAffine& getWorldMatrix(void) const { return _worldMatrix; }
    GX_FORCE_INLINE const GxVector2& getPivot(void) const { return _pivot; }
    GX_FORCE_INLINE void setPivot(const GxVector2& pivot) { _pivot = pivot; }
    GX_FORCE_INLINE void setPivot(LAYOUT layout) { _pivot = LAYOUTS[static_cast<u32>(layout)]; }
    GX_FORCE_INLINE const GxVector2& getAnchor(void) const { return _anchor; }
    GX_FORCE_INLINE void setAnchor(const GxVector2& anchor) { _anchor = anchor; }
    GX_FORCE_INLINE void setAnchor(LAYOUT layout) { _anchor = LAYOUTS[static_cast<u32>(layout)]; }
    GX_FORCE_INLINE const GxVector2 getPosition(void) const { return GxVector2(_worldMatrix.getPosition()._x, _worldMatrix.getPosition()._y); }
    GX_FORCE_INLINE const GxVector2& getLocalPosition(void) const { return _position; }
    GX_FORCE_INLINE void setLocalPosition(const GxVector2& position) { _position = position; }
    GX_FORCE_INLINE f32 getRotate(void) const { return _worldMatrix.getRotateXYZ()._z; }
    constexpr const f32 getLocalRotate(void) const { return _rotate; }
    constexpr void setLocalRotate(f32 rotate) { _rotate = rotate; }
    GX_FORCE_INLINE const GxVector2 getScale(void) const { const auto& scale = _worldMatrix.getScale(); return GxVector2(scale._x, scale._y); }
    GX_FORCE_INLINE const GxVector2& getLocalScale(void) const { return _scale; }
    GX_FORCE_INLINE void setLocalScale(const GxVector2& scale) { _scale = scale; }
    GX_FORCE_INLINE const GxColorHDR& getColor(void) const { return _color; }
    GX_FORCE_INLINE void setColor(GxColorHDR color) { _color = color; }
    constexpr void setColorA(f32 alpha) { _color._alpha = alpha; }
    constexpr BLEND_TYPE getBlendType(void) const { return _blendType; }
    constexpr void setBlendType(BLEND_TYPE type) { _blendType = type; }
    GX_FORCE_INLINE const b32 isUseMask(void) const { return _useMask; }
    GX_FORCE_INLINE void setUseMask(b32 use) { _useMask = use; }
    constexpr const f32 getPriority(void) const { return _priority; }
    constexpr const f32 getOffsetChildPriority(void) const { return _offsetChildPriority; }
    constexpr void setOffsetChildPriority(f32 priority) { _offsetChildPriority = priority; }
    constexpr void setProjectionMatrixId(u32 projectionId) { _projectionMatrixId = projectionId; }
    constexpr u32 getProjectionMatrixId(void) const { return _projectionMatrixId; }
 
#if GX_DEVELOP
    constexpr GxHandle* getHandle( void ) const { return _pHandle; }
    GX_FORCE_INLINE GxVector3* getHandlePosition( void ) { return &_handlePosition; }
    GX_FORCE_INLINE GxQuaternion* getHandleQuaternion( void ) { return &_handleQuaternion; }
    GX_FORCE_INLINE GxVector3* getHandleScale( void ) { return &_handleScale; }
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxMatrixAffine                  _worldMatrix;               
    GxRectF                         _rect;                      
    GxColorHDR                      _color;                     
    GxSize                          _size;                      
    GxVector2                       _pivot;                     
    GxVector2                       _anchor;                    
    GxVector2                       _position;                  
    GxVector2                       _scale;                     
    f32                             _rotate;                    
    f32                             _priority;                  
    f32                             _offsetChildPriority;       
    BLEND_TYPE                      _blendType;                 
    u32                             _projectionMatrixId;        
    u8                              _rootPriority;              
    b32                             _useMask;                   
    b32                             _updatedWorldMatrix;        
 
#if GX_DEVELOP
    GxHandle*                       _pHandle;                   
    GxVector3                       _handlePosition;            
    GxQuaternion                    _handleQuaternion;          
    GxVector3                       _handleScale;               
#endif // GX_DEVELOP
 
};
 
GX_CORE_NAMESPACE_END()