GxUnitSoftbodyBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_UTILITY_NAMESPACE_BEGIN()
class GxUnitSoftbodyCollision;
//===========================================================================
//===========================================================================
class GxUnitSoftbodyBase : public GxUnitBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_ABSTRACT_CLASS_NAME(GxUnitSoftbodyBase, GxUnitBase, "ソフトボディ基礎")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitSoftbodyBase)
 
    
    static const GxVector3  _gravityDefault;                
    static const GxVector3  _gravityDirectionDefault;
    static const f32        _gravityForceDefault;
    static const f32        _airDampingDefault;
    static const f32        _windForceDefault;
    static const GxVector3  _windDirectionDefault;
    static const f32        _massDefault;
    static const f32        _updateDeltaDefault;
    static const f32        _hitbackForceDamperDefault;
    static const f32        _warpLengthSquareDefault;       
 
 
    struct GxCell : public gx::core::GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        // RTTI宣言
        GX_RTTI_STRUCT(GxUnitSoftbodyBase::GxCell);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxCell(void) :
            _gravity(GxUnitSoftbodyBase::_gravityDefault),
            _mass(0.0f),
            _radius(0.0f),
            _windRatio(GxVector3::ONE),
            _isFixed(false)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxVector3       _position;          
        GxVector3       _positionCurrent;   
        GxVector3       _positionOld;       
        GxVector3       _velocity;          
        GxVector3       _force;             
        GxVector3       _normal;            
        GxVector3       _gravity;           
        f32             _mass;              
        f32             _radius;            
        GxVector3       _windRatio;         
        b32             _isFixed;           
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxUnitSoftbodyBase(void);
 
public:
    void            cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void            postAsyncUpdate(void) override;
    void            render(void) override;
 
protected:
    virtual b32             isWarp(void) = 0;
    virtual void            updateInitialize(void) = 0;
    virtual void            updateForce(f32 updateRatio, f32 updateRatioOld) = 0;
    virtual void            updateCell(void) = 0;
    virtual void            updateConstraint(void) = 0;
    virtual void            calculateHitBackForce(f32 updateRatio, f32 updateRatioOld) = 0;
 
#if GX_DEVELOP
    virtual void            developRender(void);
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
 
    virtual void*               getCellPointer(void) const = 0;
 
    constexpr GxUnitSoftbodyCollision* getCollision(void) const { return _pCollision; }
    constexpr void setCollision(GxUnitSoftbodyCollision* pCollision) { _pCollision = pCollision; }
 
 
    constexpr u32 getPointCount(void) const { return _pointCount; }
 
 
    constexpr u32 getLineCount(void) const { return _lineCount; }
 
    constexpr f32 getMass(void) const { return _mass; }
 
    constexpr f32 getAirDamping(void) const { return _airDamping; }
    constexpr void setAirDamping(f32 damping) { _airDamping = damping; }
 
    constexpr f32 getWindForce(void) const { return _windForce; }
    constexpr void setWindForce(f32 windForce) { _windForce = windForce; }
 
    GX_FORCE_INLINE const GxVector3& getWindDirection(void) const { return _windDirection; }
    GX_FORCE_INLINE void setWindDirection(const GxVector3& windDirection) { _windDirection = windDirection.getNormalizeEx(); }
 
    constexpr f32 getHitBackForceDamper(void) const { return _hitBackForceDamper; }
    constexpr void setHitBackForceDamper(f32 damper) { _hitBackForceDamper = damper; }
 
    constexpr f32 getUpdateDelta(void) const { return _updateDelta; }
    constexpr void setUpdateDelta(f32 delta) { _updateDelta = delta; }
 
    constexpr u32 getMoveStrength(u32 index) const { return _moveStrength[index]; }
 
    constexpr void setMoveStrength(u32 strength, u32 index) { _moveStrength[index] = strength; }
 
    constexpr f32 getWarpLengthSquare(void) const { return _warpLengthSquare; }
    constexpr void setWarpLengthSquare(f32 length) { _warpLengthSquare = length; }
 
    GX_FORCE_INLINE const GxVector3& getWarpPosition(void) const { return _warpPosition; }
 
    GX_FORCE_INLINE void setExtraLoop(f32 time = 1.0f) { _isExtraLoop = true; _extraLoopTime = time; }
 
    GX_FORCE_INLINE b32 isUpdateExtraLoop(void) const { return _isExtraLoop; }
    GX_FORCE_INLINE void setIsUpdateExtraLoop(void) { _isExtraLoop = true; }
 
    constexpr f32 getExtraLoopTime(void) const { return _extraLoopTime; }
    constexpr void setExtraLoopTime(f32 time) { _extraLoopTime = time; }
 
    constexpr f32 getGravityForce(void) const { return _gravityForce; }
    constexpr void setGravityForce(f32 force) { _gravityForce = force; }
 
    constexpr f32 getAdjustGravityBlendRate(void) const { return _adjustGravityBlendRate; }
    constexpr void setAdjustGravityBlendRate(f32 blandRate) { _adjustGravityBlendRate = blandRate; }
 
    GX_FORCE_INLINE const GxVector3& getGravityDirection(void) const { return _gravityDirection; }
    GX_FORCE_INLINE void setGravityDirection(const GxVector3& direction) { _gravityDirection = direction.getNormalizeEx(); }
 
    GX_FORCE_INLINE const GxVector3& getAdjustGravityDirection(void) const { return _adjustGravityDirection; }
    GX_FORCE_INLINE void setAdjustGravityDirection(const GxVector3& direction) { _adjustGravityDirection = direction.getNormalizeEx(); }
 
#if GX_DEVELOP
    GX_FORCE_INLINE void setVisible(b32 visible)            { _isVisible = visible; }
    GX_FORCE_INLINE void setVisibleWind(b32 visible)        { _isVisibleWind = visible; }
    GX_FORCE_INLINE void setVisibleMassPoint(b32 visible){ _isVisibleMassPoint = visible; }
    GX_FORCE_INLINE void setSelectedDrawMassPoint(b32 selected){ _isSelectedDrawMassPoint = selected; }
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxUnitSoftbodyCollision*    _pCollision;            
    GxUnitSoftbodyCollision*    _pCollisionOld;         
    b32*                        _pIsUpdateCollision;    
 
    u32             _pointCount;                
    u32             _lineCount;                 
    u32             _planeCount;                
 
    f32             _mass;                      
    f32             _airDamping;                
    f32             _windForce;                 
    GxVector3       _windDirection;             
    f32             _hitBackForceDamper;        
    f32             _updateDelta;               
    u32             _moveStrength[2];           
    f32             _moveStrengthCoefficient;   
    GxVector3       _warpPosition;              
    f32             _warpLengthSquare;          
    b32             _isExtraLoop;               
    f32             _extraLoopTime;             
    f32             _gravityForce;              
    GxVector3       _gravityDirection;          
    GxVector3       _adjustGravityDirection;    
    f32             _adjustGravityBlendRate;    
    b32             _isRandom;                  
    b32             _isLocalWind;               
    b32             _excludeTailJointSkin;      
 
#if GX_DEVELOP
    b32             _isUpdateconstraint;        
    b32             _isVisible;                 
    b32             _isVisibleWind;             
    GxVector3       _basePosition;              
    b32             _isVisibleMassPoint;        
    b32             _isSelectedDrawMassPoint;   
#endif // GX_DEVELOP
 
};
 
GX_UTILITY_NAMESPACE_END()