GxUnitSoftbodySimulation.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
// デフォルトユニットライン
#define USBS_DEFAULT_UNIT_PROCESS_NUMBER_SIMULATION     (4)
#define USBS_DEFAULT_UNIT_LIST_NUMBER_SIMULATION        (20)
 
GX_UTILITY_NAMESPACE_BEGIN()
class GxUnitChainModel;
class GxUnitClothModel;
//===========================================================================
//===========================================================================
class GxUnitSoftbodySimulation : public GxUnitBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS_NAME(GxUnitSoftbodySimulation, GxUnitBase, "ソフトボディシミュレーション")
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitSoftbodySimulation)
 
#if SOFTBODY_USE_REPLAY
    enum class USBS_REPLAY_STATE
    {
        NONE,       
        REPLAYING,  
        WRITING,    
 
        MAX,        
    };
#endif // SOFTBODY_USE_REPLAY
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxUnitSoftbodySimulation(void);
 
    virtual u32 initialize(GxResSoftbodySimulation* pResource, GxUnitModelBase* pParent, u32 unitProcessNumber, u32 unitListNumber, GxRtti& chainUnitRtti, GxRtti& clothUnitRtti);
 
    void            cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void            kill(void) override;
protected:
    void            asyncUpdate(void) override;
    void            sequentialUpdate(void) override;
 
public:
#if SOFTBODY_USE_REPLAY
    void                    startReplayingData(u32 replayNumber = 0, b32 isRepeat = false);
    void                    endReplayingData(void);
    void                    startWritingReplayData(u32 replayNumber = 0, u32 saveFrame = 0xFFFFFFFF);
    void                    endWritingReplayData(void);
#endif // SOFTBODY_USE_REPLAY
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void                    updateMatrix(GxUnitModelBase::GxJoint* pNow);
 
    constexpr u32 getChainCount(void) const { return _chainCount; }
 
    constexpr GxUnitChainModel* getChainUnit(u32 index) const { return _ppChainList[index]; }
    GxUnitChainModel*       getChainUnitFromID(u32 id) const;
 
    constexpr u32 getClothCount(void) const { return _clothCount; }
 
    constexpr GxUnitClothModel* getClothUnit(u32 index) const { return _ppClothList[index]; }
    GxUnitClothModel*       getClothUnitFromID(u32 id) const;
 
    GxUnitSoftbodyCollision*    getCollision(void) const;
    void                        setCollision(GxUnitSoftbodyCollision* pCollision);
 
    b32                     isSimulation(void) const;
    b32 isSimulationChain(u32 index) const;
    b32 isSimulationCloth(u32 index) const;
 
    void                    setIsSimulation(b32 enable);
 
    b32                     isInterpolateToMotion(void) const;
    b32 isInterpolateToMotionChain(u32 index) const;
    b32 isInterpolateToMotionCloth(u32 index) const;
 
    void                    forceDisableSimulation(void);
 
    f32                     getInterpolateTime(void) const;
    void                    setInterpolateTime(f32 time);
 
    b32                     isMotionGravity(void) const;
    void                    setIsMotionGravity(b32 enable);
 
    void                    setMotionGravity(b32 enable, f32 gravityForce, const GxVector3& gravityDirection = -GxVector3::AXIS_Y);
 
    GX_FORCE_INLINE GxVector3 getGravity(void) const { return getGravityForce() * getGravityDirection(); }
    void                    setGravity(const GxVector3 & gravity);
    f32                     getGravityForce(void) const;
    void                    setGravityForce(f32 force);
    const GxVector3&        getGravityDirection(void) const;
    void                    setGravityDirection(const GxVector3& direction);
 
    GX_FORCE_INLINE GxVector3 getWind(void) const { return getWindForce() * getWindDirection(); }
    void                    setWind(const GxVector3& wind);
    f32                     getWindForce(void) const;
    void                    setWindForce(f32 force);
    const GxVector3&        getWindDirection(void) const;
    void                    setWindDirection(const GxVector3& direction);
 
    GX_FORCE_INLINE b32 isUpdateAllMatrix(void) const { return _isUpdateAllMatrix; }
    GX_FORCE_INLINE void setIsUpdateAllMatrix(b32 is) { _isUpdateAllMatrix = is; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE virtual b32 isDevelopRender(void) const { return _isDevelopRender; }
    virtual void            setDevelopRender(b32 enable);
    virtual void            setDevelopRenderMassPoint(b32 enable);
    virtual void            setForceDevelopRender(b32 enable);
 
    GX_FORCE_INLINE void getPropertyWindForce(void* const pValue) const { *static_cast<f32*>(pValue) = getWindForce(); }
    GX_FORCE_INLINE void setPropertyWindForce(const void* const pValue) { setWindForce(*static_cast<f32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void getPropertyWindDirection(void* const pValue) const { *static_cast<GxVector3*>(pValue) = getWindDirection(); }
    GX_FORCE_INLINE void setPropertyWindDirection(const void* const pValue) { setWindDirection( *static_cast<GxVector3*>(const_cast<void*>(pValue)) ); }
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResSoftbodySimulation*        _pResource;             
    GxUnitModelBase*                _pParentModel;          
    GxUnitChainModel**              _ppChainList;           
    GxUnitClothModel**              _ppClothList;           
    u32                             _chainCount;            
    u32                             _clothCount;            
    b32                             _isUpdateAllMatrix;     
 
    GxUnitSoftbodyCollision*        _pCollision;            
 
#if SOFTBODY_USE_REPLAY
    b32                             _startReplayRead;       
    b32                             _endReplayRead;         
    b32                             _startReplayWrite;      
    b32                             _endReplayWrite;        
    u32                             _replayState;           
    u32                             _replayNumber;          
    u32                             _replayFrame;           
    u32                             _saveFrame;             
    b32                             _isRepeat;              
    b32                             _enableOld;             
    GxString                        _path;                  
    GxResSoftbodySimulationReplay*  _pReplayResource;       
    GxResSoftbodySimulationReplayXml*   _pReplayResourceXml;    
#endif // SOFTBODY_USE_REPLAY
 
#if GX_DEVELOP
    b32     _enable;                
    b32     _isDevelopRender;       
#endif // GX_DEVELOP
 
};
 
GX_UTILITY_NAMESPACE_END()