GxUnitClothModel.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_UTILITY_NAMESPACE_BEGIN()
//===========================================================================
//===========================================================================
class GxUnitClothModel : public GxUnitClothBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS_NAME(GxUnitClothModel, GxUnitClothBase, "モデル基準布")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitClothModel)
 
    
    enum class UCM_UPDATESTATE
    {
        RESET_TO_SIMULATION,        
        SIMULATION,                 
        INTERPOLATION_TO_MOTION,    
        MOTION,                     
    };
 
 
    struct GxAdditionalData : public GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GX_RTTI_STRUCT(GxUnitClothModel::GxAdditionalData);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxAdditionalData(void) :
            _quaternionOld(GxQuaternion::IDENTITY),
            _jointIndex(-1),
            _radius(0.0f),
            _twistLimit(PI),
            _isHitBack(false),
            _twist(GxQuaternion::IDENTITY),
            _angleLimit(PI),
            _baseRatio(0.0f),
            _windRatio(GxVector3::ONE),
            _isEnableLink(true)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxQuaternion        _quaternionOld;     
        s32                 _jointIndex;        
        f32                 _radius;            
        f32                 _twistLimit;        
        b32                 _isHitBack;         
        GxVector3           _normal;            
        GxVector3           _hitBackDirect;     
        GxQuaternion        _twist;             
        GxVector3           _angleAxis;         
        f32                 _angleLimit;        
        f32                 _baseRatio;         
        GxVector3           _windRatio;         
        b32                 _isEnableLink;      
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxUnitClothModel(void);
 
    void            cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void            kill(void) override;
 
    b32                     initialize(GxResSoftbodySimulation::GxSoftbodyClothData* pCloth, GxUnitModelBase* pParent);
 
protected:
    b32             setup(void) override;
    void            postAsyncUpdate(void) override;
 
protected:
    void                    resetup(void);
    b32                     interpolateToMotion(void);
 
    virtual void            updateModel(void);
    virtual void            updateInterpolateModel(void);
 
    // 以下、手法を変えるときのみオーバーライド
 
    b32             isWarp(void) override;
    void            updateInitialize(void) override;
    void            interpolatePosition(f32 updateRatio, f32 updateRatioOld) override;
    void            calculateExternalForce(GxVector3& windDirect) override;
    void            calculateHitBackForce(f32 updateRatio, f32 updateRatioOld) override;
    void            updateConstraint(void) override;
    virtual b32     analyseCollisionJoint(GxUnitSoftbodyCollision::GxHitBase* pHitBase);
    virtual void    updateCollisionAfterSimulation(void);
 
#if GX_DEVELOP
    void            developRender(void) override;
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    virtual void            setAdditionalData(GxResSoftbodySimulation::GxSoftbodyClothAdditionalData * pResourceAdditionalData);
 
    GX_FORCE_INLINE b32 isMotionGravity(void) const { return _isUseMotionGravity; }
    GX_FORCE_INLINE void setIsMotionGravity(b32 enable) { _isUseMotionGravity = enable; }
 
 
    void                    setMotionGravity(b32 enable, f32 gravityForce, const GxVector3& gravityDirection = -GxVector3::AXIS_Y);
 
 
    constexpr void reset(void) { _updateState = UCM_UPDATESTATE::RESET_TO_SIMULATION; }
 
    GX_FORCE_INLINE b32 isClothSimulation(void) const { return _isClothSimulation; }
 
    GX_FORCE_INLINE void setIsClothSimulation(b32 enable) { _isClothSimulation = enable; }
 
 
    GX_FORCE_INLINE b32 isInterpolateToMotion(void) const { return ( UCM_UPDATESTATE::INTERPOLATION_TO_MOTION == _updateState ); }
 
    GX_FORCE_INLINE void forceDisableClothSimulation(void) { _isClothSimulation = false; _updateState = UCM_UPDATESTATE::MOTION; }
 
    constexpr f32 getInterpolateTime(void) const { return _interpolateTime; }
    constexpr void setInterpolateTime(f32 time) { _interpolateTime = time; }
 
public:
    GX_FORCE_INLINE const GxAdditionalData** getAdditionalData(void) const { return const_cast<const GxAdditionalData**>(_ppAdditionalData); }
 
    constexpr s32 getJointIndex(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._jointIndex; }
    constexpr void setJointIndex(u32 pointIndex, u32 lineIndex, s32 no) { _ppAdditionalData[lineIndex][pointIndex]._jointIndex = no; }
 
    GX_FORCE_INLINE const GxQuaternion& getOldQuaternion(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._quaternionOld; }
    GX_FORCE_INLINE void setOldQuaternion(u32 pointIndex, u32 lineIndex, GxQuaternion & quaternion) { _ppAdditionalData[lineIndex][pointIndex]._quaternionOld = quaternion; }
 
    constexpr f32 getRadius(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._radius; }
    constexpr void setRadius(u32 pointIndex, u32 lineIndex, f32 radius) { _ppAdditionalData[lineIndex][pointIndex]._radius = radius; }
 
    GX_FORCE_INLINE const GxQuaternion& getTwist(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._twist; }
    GX_FORCE_INLINE void setTwist(u32 pointIndex, u32 lineIndex, const GxQuaternion & twist) { _ppAdditionalData[lineIndex][pointIndex]._twist = twist; }
 
    constexpr f32 getTwistLimit(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._twistLimit; }
    constexpr void setTwistLimit(u32 pointIndex, u32 lineIndex, f32 limit) { _ppAdditionalData[lineIndex][pointIndex]._twistLimit = limit; }
 
    GX_FORCE_INLINE const GxVector3& getHitBackDir(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._hitBackDirect; }
    GX_FORCE_INLINE void setHitBackDir(u32 pointIndex, u32 lineIndex, const GxVector3 & direct) { _ppAdditionalData[lineIndex][pointIndex]._hitBackDirect = direct; }
 
    GX_FORCE_INLINE b32 isHitBack(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._isHitBack; }
    GX_FORCE_INLINE void setIsHitBack(u32 pointIndex, u32 lineIndex, b32 isHitBack) { _ppAdditionalData[lineIndex][pointIndex]._isHitBack = isHitBack; }
 
    // Normal は GxCell と GxAdditionalData の両方に存在するので注意
    GX_FORCE_INLINE const GxVector3& getAdditionalNormal(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._normal; }
    GX_FORCE_INLINE void setAdditionalNormal(u32 pointIndex, u32 lineIndex, const GxVector3& normal) { _ppAdditionalData[lineIndex][pointIndex]._normal = normal; }
 
    constexpr f32 getAngleLimit(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._angleLimit; }
    constexpr void setAngleLimit(u32 pointIndex, u32 lineIndex, f32 limit) { _ppAdditionalData[lineIndex][pointIndex]._angleLimit = limit; }
 
    GX_FORCE_INLINE const GxVector3& getAngleAxis(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._angleAxis; }
    GX_FORCE_INLINE void setAngleAxis(u32 pointIndex, u32 lineIndex, const GxVector3& axis) { _ppAdditionalData[lineIndex][pointIndex]._angleAxis = axis; }
 
    constexpr f32 getBaseRatio(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._baseRatio; }
    constexpr void setBaseRatio(u32 pointIndex, u32 lineIndex, f32 baseRatio) { _ppAdditionalData[lineIndex][pointIndex]._baseRatio = baseRatio; }
 
    GX_FORCE_INLINE GxVector3 getWindRatio(u32 pointIndex, u32 lineIndex) const { return _ppAdditionalData[lineIndex][pointIndex]._windRatio; }
    GX_FORCE_INLINE void setWindRatio(u32 pointIndex, u32 lineIndex, GxVector3& windRatio) { _ppAdditionalData[lineIndex][pointIndex]._windRatio = windRatio; }
 
    constexpr u32 getID(void) const { return _id; }
 
    constexpr u32 getPointCount(void) const { return _pointCount; }
    constexpr u32 getLineCount(void) const { return _lineCount; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE void setSelectMassPointIndex(u32 pointIndex, u32 lineIndex){ _selectPointIndex = GxMath::getMin<u32>(_pointCount - 1, pointIndex); _selectLineIndex = GxMath::getMin<u32>(_lineCount - 1, lineIndex); }
    constexpr void getSelectPointIndex(void* const pValue) { *static_cast<u32*>(pValue) = _selectPointIndex; }
    GX_FORCE_INLINE void setSelectPointIndex(const void* const pValue){ _selectPointIndex = GxMath::getMin<u32>(_pointCount - 1, *static_cast<u32*>(const_cast<void*>(pValue))); }
    constexpr void getSelectLineIndex(void* const pValue) { *static_cast<u32*>(pValue) = _selectLineIndex; }
    GX_FORCE_INLINE void setSelectLineIndex(const void* const pValue){ _selectLineIndex = GxMath::getMin<u32>(_lineCount - 1, *static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE b32 isForceDevelopRneder(void) const { return _isForceDevelopRneder; }
    GX_FORCE_INLINE void setForceDevelopRneder(b32 enable) { _isForceDevelopRneder = enable; }
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32                     _isUseAdditionalData;       
    b32                     _isUseMotionGravity;        
 
    GxAdditionalData**      _ppAdditionalData;          
    GxUnitModelBase*        _pParentModel;              
 
    b32                     _isClothSimulation;         
    UCM_UPDATESTATE         _updateState;               
    f32                     _interpolateTime;           
    f32                     _interpolateInnerTime;      
    b32                     _isUpdateAllMatrix;         
 
    f32                     _twistInterpolateSpeed;     
 
    GxVector3*              _pTailOffsetLocal;          
    GxVector3*              _pTailOffsetWorld;          
 
#if GX_DEVELOP
    u32                     _selectPointIndex;          
    u32                     _selectLineIndex;           
    b32                     _isForceDevelopRneder;      
#endif // GX_DEVELOP
 
};
 
GX_UTILITY_NAMESPACE_END()