GxBackgroundHit.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_PHYSICS_NAMESPACE_BEGIN()
 
#define USE_OBJ_ADJUST  1   // ver-2.9.0削除予定
 
//===========================================================================
//===========================================================================
class GxBackgroundHit : public GxAdjustHit
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxBackgroundHit, GxAdjustHit )
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxBackgroundHit )
 
    
    static const GxColor COLOR_OBJECT;  
 
    class GxWorld;
    class GxObject;
 
    class   GxConditionInformationBackgroundHit;    
    struct  GxRayCallback;                          
    struct  GxConvexCallback;                       
 
protected:
    enum class ADJUST_FLAG_INDEX
    {
        ON,                 
        END,                
        OLD_POS,            
        THROUGH_ONCE,       
        THROUGH_ONCE_OLD,   
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxBackgroundHit(void);
 
    ~GxBackgroundHit(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxCollision::GxObject* allocObject(void) override;
 
    GxObject* getObject(u32 index);
 
    void checkOldPosition( GxRayResult& result, const GxVector3& moveVector, const GxVector3& offset, GxCollision::GxConditionInformation* pCondition = nullptr ) override;
 
    const GxVector3& calculateAdjustVector( void ) override;
 
    void update(void) override;
 
    void executePostCheckCallback(void) override;
 
#if GX_DEVELOP
    void developDrawObject(const GxColor& color = GxColor::WHITE, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
 
    GX_FORCE_INLINE static void setDevelopDrawBackgroundHitObject(b32 display) { getGxSysMain()->setDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_BACKGROUND_HIT_OBJECT, display); }
    GX_FORCE_INLINE static void setDevelopDrawBackgroundHitMesh(b32 display) { getGxSysMain()->setDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_BACKGROUND_HIT_MESH, display); }
 
    GX_FORCE_INLINE static b32 getDevelopDrawBackgroundHitObject(void) { return getGxSysMain()->isOnDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_BACKGROUND_HIT_OBJECT); }
    GX_FORCE_INLINE static b32 getDevelopDrawBackgroundHitMesh(void) { return getGxSysMain()->isOnDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_BACKGROUND_HIT_MESH); }
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE void addObjectHitAdjust( const GxVector3& adjust ) { _isAdjustedObjectHit = true; _objectHitAdjust += adjust; }
    GX_FORCE_INLINE const GxVector3& getObjectHitAdjust( void ) const { return _objectHitAdjust; }
    GX_FORCE_INLINE void resetObjectHitAdjust( void ) { _isAdjustedObjectHit = false; _objectHitAdjust = GxVector3::ZERO; }
    GX_FORCE_INLINE b32 isAdjustedObjectHit( void ) const { return _isAdjustedObjectHit; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GX_FORCE_INLINE void getPropertyCheckMargin(void* const pValue) const { *static_cast<f32*>(pValue) = _checkMargin; }
    GX_FORCE_INLINE void setPropertyCheckMargin(const void* const pValue) { _checkMargin = *static_cast<f32*>(const_cast<void*>(pValue)); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxFlag32Index<ADJUST_FLAG_INDEX> _backgroundHitFlag;    
 
    GxVector3   _objectHitAdjust;       
    b32         _isAdjustedObjectHit;   
 
};
 
//===========================================================================
//===========================================================================
class GxBackgroundHit::GxWorld : public GxAdjustHit::GxWorld
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxBackgroundHit::GxWorld, GxAdjustHit::GxWorld )
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxWorld )
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxWorld(void);
 
    ~GxWorld( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void postCheck( void ) override;
 
    GxCollision::GxRayCallback* createRayCallback( const btVector3& rayFrom, const btVector3& rayEnd, GxConditionInformation* pConditionInfo ) override;
 
    b32 checkRayClosestVsTrimesh( GxCollision::GxRayResult& rayResult, const GxVector3& startPosition, const GxVector3& endPosition, GxConditionInformationBackgroundHit* pConditionInfo = nullptr );
 
    GxCollision::GxConvexCallback* createConvexCallback( const btVector3& checkFrom, const btVector3& checkEnd, GxConditionInformation* pConditionInfo ) override;
 
    b32 checkCapsuleClosestVsTrimesh( GxCollision::GxRayResult& rayResult, const GxVector3& startPosition, const GxVector3& endPosition, f32 radius, GxConditionInformationBackgroundHit* pConditionInfo = nullptr );
 
protected:
    f32 calculateAdjustRate( GxAdjustHit::GxObject* pObjectA, GxAdjustHit::GxObject* pObjectB) override;
 
};
 
//===========================================================================
//===========================================================================
class GxBackgroundHit::GxObject : public GxAdjustHit::GxObject
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxBackgroundHit::GxObject, GxAdjustHit::GxObject )
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxObject )
 
    
    enum class TYPE
    {
        KINEMATIC,  
        STATIC,     
        ERROR_,     
        MAX,        
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(TYPE)
#endif //GX_DEVELOP
 
    enum GROUP
    {
        GROUP_OBJECT        = (0x01 << 0),  
        GROUP_BACKGROUND    = (0x01 << 1),  
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject(void);
 
    ~GxObject(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr TYPE getType(void) const { return _type; }
 
    void setType(TYPE type);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);
#endif // GX_DEVELOP
 
protected:
    GxVector3 checkOldPositionMultisphere(const GxVector3& adjustVector, const GxVector3& moveVector);
    GxVector3 checkOldPositionCapsule(const GxVector3& adjustVector, const GxVector3& moveVector);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:    
    TYPE            _type;  
 
};
 
//===========================================================================
//===========================================================================
class GxBackgroundHit::GxConditionInformationBackgroundHit : public GxCollision::GxConditionInformation
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxBackgroundHit::GxConditionInformationBackgroundHit, GxCollision::GxConditionInformation )
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformationBackgroundHit(void) : _type(GxObject::TYPE::ERROR_) {}
 
    const GxConditionInformationBackgroundHit& operator = (const GxConditionInformation& rhs)
    {
        *static_cast<GxConditionInformation*>(this) = rhs;
        return *this;
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject::TYPE _type;   
 
};
 
//===========================================================================
//===========================================================================
struct GxBackgroundHit::GxRayCallback : public GxCollision::GxRayCallback
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxRayCallback( const btVector3& rayFromWorld,const btVector3& rayToWorld, GxConditionInformation* pConditionInfo )
        : GxCollision::GxRayCallback( rayFromWorld, rayToWorld, pConditionInfo )
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    bool needsCollision(btBroadphaseProxy* pProxy) const override;
 
};
 
//===========================================================================
//===========================================================================
struct GxBackgroundHit::GxConvexCallback : public GxCollision::GxConvexCallback
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxConvexCallback( const btVector3& rayFromWorld,const btVector3& rayToWorld, GxConditionInformation* pConditionInfo )
        : GxCollision::GxConvexCallback( rayFromWorld, rayToWorld, pConditionInfo )
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    bool needsCollision(btBroadphaseProxy* pProxy) const override;
 
};
 
GX_PHYSICS_NAMESPACE_END()