GxUnitChainModel.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_UTILITY_NAMESPACE_BEGIN()
//===========================================================================
//===========================================================================
class GxUnitChainModel : public GxUnitChainBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS_NAME(GxUnitChainModel, GxUnitChainBase, "モデル基準鎖")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitChainModel)
 
    
    enum class UCM_UPDATESTATE
    {
        RESET_TO_SIMULATION,        
        SIMULATION,                 
        INTERPOLATION_TO_MOTION,    
        MOTION,                     
    };
 
 
    struct GxAdditionalData : public GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        // RTTI宣言
        GX_RTTI_STRUCT(GxUnitChainModel::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)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxQuaternion        _quaternionOld;     
        s32                 _jointIndex;        
        f32                 _radius;            
        f32                 _twistLimit;        
        b32                 _isHitBack;         
        GxVector3           _normal;            
        GxVector3           _hitBackDirect;     
        GxQuaternion        _twist;             
        GxVector3           _angleAxis;         
        f32                 _angleLimit;        
        f32                 _baseRatio;         
        GxVector3           _windRatio;         
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxUnitChainModel(void);
 
    b32             initialize(GxResSoftbodySimulation::GxSoftbodyChainData* pChain, GxUnitModelBase* pParent);
 
    void            cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void            kill(void) override;
protected:
    b32             setup(void) override;
    void            postAsyncUpdate(void) override;
 
public:
    virtual void            setAdditionalData(GxResSoftbodySimulation::GxSoftbodyChainAdditionalData* 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 isChainSimulation(void) const { return _isChainSimulation; }
 
    GX_FORCE_INLINE void setIsChainSimulation(b32 enable) { _isChainSimulation = enable; }
 
 
    GX_FORCE_INLINE b32 isInterpolateToMotion(void) const { return ( UCM_UPDATESTATE::INTERPOLATION_TO_MOTION == _updateState ); }
 
    GX_FORCE_INLINE void forceDisableChainSimulation(void) { _isChainSimulation = false; _updateState = UCM_UPDATESTATE::MOTION; }
 
    constexpr f32 getInterpolateTime(void) const { return _interpolateTime; }
    constexpr void setInterpolateTime(f32 time) { _interpolateTime = time; }
 
protected:
    virtual 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);
 
public:
#if GX_DEVELOP
    void            developRender(void) override;
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxAdditionalData* getAdditionalData(void) const { return const_cast<const GxAdditionalData *>(_pAdditionalData); }
 
    constexpr s32 getJointIndex(u32 index) const { if(index < _pointCount) return _pAdditionalData[index]._jointIndex; else return -1; }
    constexpr void setJointIndex(u32 index, s32 jointIndex) { _pAdditionalData[index]._jointIndex = jointIndex; }
 
    const GxQuaternion& getOldQuaternion(u32 index) const { return _pAdditionalData[index]._quaternionOld; }
    GX_FORCE_INLINE void setOldQuaternion(u32 index, const GxQuaternion& quaternion) { _pAdditionalData[index]._quaternionOld = quaternion; }
 
    constexpr f32 getRadius(u32 index) const { if( index < _pointCount ) return _pAdditionalData[index]._radius; else return 0.0f; }
    constexpr void setRadius(u32 index, f32 radius) { _pAdditionalData[index]._radius = radius; }
 
    const GxQuaternion& getTwist(u32 index) const { return _pAdditionalData[index]._twist; }
    GX_FORCE_INLINE void setTwist(u32 index, const GxQuaternion& twist) { _pAdditionalData[index]._twist = twist; }
 
    constexpr f32 getTwistLimit(u32 index) const { return _pAdditionalData[index]._twistLimit; }
    constexpr void setTwistLimit(u32 index, f32 limit) { _pAdditionalData[index]._twistLimit = limit; }
 
    GX_FORCE_INLINE const GxVector3& getNormal(u32 index) const { return _pAdditionalData[index]._normal; }
    GX_FORCE_INLINE void setNormal(u32 index, const GxVector3& normal) { _pAdditionalData[index]._normal = normal; }
 
    GX_FORCE_INLINE const GxVector3& getHitBackDir(u32 index) const { return _pAdditionalData[index]._hitBackDirect; }
    GX_FORCE_INLINE void setHitBackDir(u32 index, const GxVector3& dir) { _pAdditionalData[index]._hitBackDirect = dir; }
 
    GX_FORCE_INLINE b32 isHitBack(u32 index) const { return _pAdditionalData[index]._isHitBack; }
    GX_FORCE_INLINE void setIsHitBack(u32 index, b32 isHitBack) { _pAdditionalData[index]._isHitBack = isHitBack; }
 
    constexpr f32 getAngleLimit(u32 index) const { return _pAdditionalData[index]._angleLimit; }
    constexpr void setAngleLimit(u32 index, f32 limit) { _pAdditionalData[index]._angleLimit = limit; }
 
    GX_FORCE_INLINE const GxVector3& getAngleAxis(u32 index) const { return _pAdditionalData[index]._angleAxis; }
    GX_FORCE_INLINE void setAngleAxis(u32 index, const GxVector3& axis) { _pAdditionalData[index]._angleAxis = axis; }
 
    constexpr f32 getBaseRatio(u32 index) const { return _pAdditionalData[index]._baseRatio; }
    constexpr void setBaseRatio(u32 index, f32 baseRatio) { _pAdditionalData[index]._baseRatio = baseRatio; }
 
    GX_FORCE_INLINE GxVector3 getWindRatio(u32 index) const { return _pAdditionalData[index]._windRatio; }
    GX_FORCE_INLINE void setWindRatio(u32 index, GxVector3& windRatio) { _pAdditionalData[index]._windRatio = windRatio; }
 
    constexpr u32 getID(void) const { return _id; }
    constexpr u32 getPointCount(void) const { return _pointCount;  }
 
#if GX_DEVELOP
    GX_FORCE_INLINE void setSelectMassPointIndex(u32 index){ _selectJointIndex = GxMath::getMin<u32>(_pointCount - 1, index); }
    constexpr void getSelectJointIndex(void* const pValue) { *static_cast<u32*>(pValue) = _selectJointIndex; }
    GX_FORCE_INLINE void setSelectJointIndex(const void* const pValue){ _selectJointIndex = GxMath::getMin<u32>(_pointCount - 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*       _pAdditionalData;           
    GxUnitModelBase*        _pParentModel;              
 
    b32                     _isChainSimulation;         
    UCM_UPDATESTATE         _updateState;               
    f32                     _interpolateTime;           
    f32                     _interpolateInnerTime;      
    b32                     _isUpdateAllMatrix;         
 
    f32                     _twistInterpolateSpeed;     
 
    GxVector3               _tailOffsetLocal;           
    GxVector3               _tailOffsetWorld;           
 
#if GX_DEVELOP
    u32                     _selectJointIndex;          
    b32                     _isForceDevelopRneder;      
#endif // GX_DEVELOP
 
};
 
GX_UTILITY_NAMESPACE_END()