GxUnitLocate.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
// 外部クラスの前方宣言
#if GX_DEVELOP
class GxHandle;
#endif // GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxUnitLocate : public GxUnitBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS_NAME(GxUnitLocate, GxUnitBase, "3D座標基礎")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitLocate)
 
    
    enum class MOVABLE
    {
        NONE,       
        STATIC,     
        DYNAMIC,    
        MAX,        
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(MOVABLE)
#endif //GX_DEVELOP
 
    enum class CULLING_FRUSTUM
    {
        NORMAL,         
        SHADOW_0,       
        SHADOW_1,       
        SHADOW_2,       
        SHADOW_3,       
        POINT_SHADOW_0, 
        POINT_SHADOW_1, 
        REFLECTION,     
        POST,           
        OTHER,          
        MAX,            
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxUnitLocate(void);
 
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void kill(void) override;
 
    virtual void frustumCulling(void* pFrustum);
    virtual void forceSetCullingFlag(u32 argument);
    virtual void buildSpaceGraph(void* pOctree);
    virtual void eraseSpaceGraph(void* pOctree);
 
protected:
    static CULLING_FRUSTUM getFrustumType(const RENDER_SUB_VIEW subview);
 
    virtual void updateSpaceGraph(GxOtFrustumCulling* pOctree);
 
    b32 setup(void) override;
    void preAsyncUpdate(void) override;
    void asyncUpdate(void) override;
    void forceAsyncUpdate(void) override;
    void render(void) override;
 
#if GX_DEVELOP
    virtual void developRender(void);
    GX_FORCE_INLINE virtual void iconRender(void) {}
    void drawIcon(const s32 size = 32);
public:
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif //GX_DEVELOP
public:
    GX_FORCE_INLINE virtual void updateLocalMatrix(void) {}
    virtual void updateWorldMatrix(void);
 
    void addX(f32 value);
    void addY(f32 value);
    void addZ(f32 value);
    void addPosition(const GxVector3& moveVector);
    void addQuaternion(const GxQuaternion& quaternion);
    void rotateAxisY(const GxVector3& vector, f32 radian);
    void rotateAxisZ(const GxVector3& vector, f32 radian);
 
    b32 isAbleAddToOctree(void);
    b32 isAbleDeleteFromOctree(void);
 
private:
    b32 isHitBoundingSphere(const RENDER_VIEW view) const;
#if GX_DEVELOP
    void controlHandle(void);
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxMatrixAffine& getWorldMatrix(void) const { return _worldMatrix; }
    void getWorldMatrix(GxMatrixAffine& matrix) const;
    GX_FORCE_INLINE void setWorldMatrix(const GxMatrixAffine& matrix){ _worldMatrix = matrix; }
    GX_FORCE_INLINE GxMatrixAffine* getWorldMatrixAddress(void){ return &_worldMatrix; }
    GX_FORCE_INLINE const GxVector3& getPosition(void) const { return _worldMatrix.getPosition(); }
    GX_FORCE_INLINE virtual void setPosition(const GxVector3& position)
    {
        auto* pParentLocate = static_cast<GxUnitLocate*>(getParent());
        _position = pParentLocate ? (position - pParentLocate->getPosition()) : position;
    }
    GX_FORCE_INLINE const GxVector3& getLocalPosition(void) const { return _position; }
    GX_FORCE_INLINE virtual void setLocalPosition(const GxVector3& position) { _position = position; }
    GX_FORCE_INLINE GxQuaternion getQuaternion(void) const { return GxQuaternion(_worldMatrix); }
    GX_FORCE_INLINE void setQuaternion(const GxQuaternion& quaternion)
    {
        auto* pParentLocate = gx_cast<GxUnitLocate*>(getParent());
        _quaternion = pParentLocate ? (quaternion * pParentLocate->getQuaternion().getInverse()) : quaternion;
    }
    GX_FORCE_INLINE const GxQuaternion& getLocalQuaternion(void) const { return _quaternion; }
    GX_FORCE_INLINE void setLocalQuaternion(const GxQuaternion& quaternion) { _quaternion = quaternion; }
    GX_FORCE_INLINE GxVector3 getScale(void) const { return _worldMatrix.getScale(); }
    GX_FORCE_INLINE virtual void setScale(const GxVector3& scale)
    {
        auto* pParentLocate = gx_cast<GxUnitLocate*>(getParent());
        _scale = pParentLocate ? (scale / pParentLocate->getScale()) : scale;
    }
    GX_FORCE_INLINE const GxVector3& getLocalScale(void) const { return _scale; }
    GX_FORCE_INLINE virtual void setLocalScale(const GxVector3& scale) { _scale = scale; }
    GX_FORCE_INLINE const GxShapeSphere& getBoundingSphere(void) const { return _boundingSphere; }
    GX_FORCE_INLINE void setBoundingSphere( const GxShapeSphere& sphere ){ _boundingSphere = sphere; }
    void getBoundingSphereWorld(GxShapeSphere& sphere) const;
 
    GX_FORCE_INLINE b32 isCulling(RENDER_VIEW view, u32 subView) const { return _frustumCullingFlag[static_cast<s32>(view)][subView]; }
    GX_FORCE_INLINE b32 isCullingEnable(void) const { return _cullingEnableFlag; }
    GX_FORCE_INLINE void setCullingEnable(b32 flag){ _cullingEnableFlag = flag; }
    GX_FORCE_INLINE b32 enabledHierarchicalCulling(void) const { return _useAdaCulling; }
    GX_FORCE_INLINE void setHierarchicalCulling(b32 flag) { _useAdaCulling = flag; }
    GX_FORCE_INLINE b32 isDoneHierarchicalCulling(void) const { return _doneCulling; }
    GX_FORCE_INLINE void doneHierarchicalCulling(b32 flag) { _doneCulling = flag; }
    constexpr u32 getCullingState(void) const { return _cullingState; }
    constexpr void setCullingState(u32 flag) { _cullingState = flag; }
    constexpr void clearCullingState(void) { _cullingState = 0; }
 
    GX_FORCE_INLINE b32 isMovable(MOVABLE movable) const { return _movable == movable; }
    void setMovable(MOVABLE movable);
    GX_FORCE_INLINE b32 isDirtyMovable(void) const { return _movableChanged; }
    GX_FORCE_INLINE void setDirtyMovable(b32 enable){ _movableChanged = enable; }
 
#if GX_DEVELOP
    constexpr GxHandle* getHandle( void ) const { return _pHandle; }
    GX_FORCE_INLINE b32 isIconFlag(void) const { return _iconFlag; }
    GX_FORCE_INLINE void setIconFlag(const b32 iconFlag) { _iconFlag = iconFlag; }
    constexpr GX_HANDLE getIconHandle(void) const { return _iconHandle; }
    constexpr void setIconHandle(const GX_HANDLE iconHandle) { _iconHandle = iconHandle;}
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxMatrixAffine  _worldMatrix;           
    GxVector3       _position;              
    GxQuaternion    _quaternion;            
    GxVector3       _scale;                 
 
    GxShapeSphere   _boundingSphere;        
    MOVABLE         _movable;               
    b32             _movableChanged;        
    b32             _frustumCullingFlag[static_cast<s32>(RENDER_VIEW::_3D_MAX)][static_cast<s32>(CULLING_FRUSTUM::MAX)];            
    b32             _cullingEnableFlag;     
    b32             _useAdaCulling;         
    b32             _doneCulling;           
    u32             _cullingState;          
    b32             _updatedWorldMatrix;    
#if GX_DEVELOP
    GxHandle*       _pHandle;               
    b32             _iconFlag;              
    GX_HANDLE       _iconHandle;            
#endif // GX_DEVELOP
 
};
 
GX_CORE_NAMESPACE_END()