GxMotionPlayer.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_MOTION_NAMESPACE_BEGIN()
 
class GxIkChain;
class GxMotionJoint;
class GxMotionJointData;
class GxResMotionPackage;
class GxResMotionInterpolationSettings;
//===========================================================================
//===========================================================================
class GxMotionPlayer : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxMotionPlayer, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxMotionPlayer)  
 
    // friend宣言
    friend class GxModUnitMotionBlend;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxMotionPlayer(void);
    ~GxMotionPlayer(void) override;
    void initialize(GxResMotionPackage* pResource);
    virtual void reset(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GX_FORCE_INLINE virtual b32 isExistScale(const GxMotionJointData* pJoint) const { return pJoint->getScale() != GxVector3::ONE; }
protected:
    b32 loadBasepose(void const* pBasePoseData);
    virtual void allocateJointArray(void);
public:
    void updateFrame(void);
    void updateJointLocalData(void);
    b32 change(s32 motionNumber = static_cast<s32>(GxModUnitMotionBase::MOTION_INDEX::BEGIN), f32 startFrame = 0.f, f32 speedRatio = 1.f, f32 transitionFrameNumber = 0.f, u32 playbackFlags = 0);
    b32 changeMotion(s32 motionNumber = static_cast<s32>(GxModUnitMotionBase::MOTION_INDEX::BEGIN));
    void updateJointMatrices(u32 jointStartNumber, u32 jointCount);
    GX_FORCE_INLINE void updateJoints(void){ updateJointLocalData(); updateJointMatrices(static_cast<s32>(GxModUnitMotionBase::NODE::LOCATOR_ROOT), getJointCount()); }
protected:
    virtual void updateRootPosition(void);
    GxMatrixAffine& calculateJointMatrix(GxMotionJoint const* pFinalJoint, GxMatrixAffine& jointMatrix);
 
    virtual void calculateInterpolation(void);
 
    void calculateLocalData2BonesIK(u32 chainStartJointNumber);
    void calculateMotionDataMatrices2BonesIK(u32 chainStartJointNumber);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    void setMotionNumber(s32 motionNumber);
    GX_FORCE_INLINE virtual f32 getFrame(void) const { return _pMotionCurvesContainer ? _pMotionCurvesContainer->getFrame() : 0.0f; }
    void setFrame(f32 frame);
    GX_FORCE_INLINE virtual f32 getFrameNumber(f32 milliSeconds) const { return _deltaTimeRatio * _speed * getGxRenderDevice()->getFrameRateTargetF32() * milliSeconds / GxMath::MILLI_INVERSE; }
    GX_FORCE_INLINE virtual f32 getMilliSeconds(f32 frameNumber) const { return ((frameNumber * GxMath::MILLI_INVERSE)/(_speed * getGxRenderDevice()->getFrameRateTargetF32())) / _deltaTimeRatio; }
    GX_FORCE_INLINE virtual f32 getSpeed(void) const { return _speed; }
    constexpr void setSpeed(f32 speed){ _speed = speed; }
    GX_FORCE_INLINE virtual u32 getPlaybackFlags(void) const { return _playbackFlags; }
    GX_FORCE_INLINE virtual b32 isPlaybackFlag(MOTION_PLAYBACK_FLAG flag) const { return (_playbackFlags&flag) != 0; }
    void setPlaybackFlags(u32 playbackFlags);
    void setPlaybackFlag(MOTION_PLAYBACK_FLAG flag, b32 value);
    constexpr f32 getDeltaTime(void) const { return _deltaTime; }
    constexpr f32 getDeltaTimeRatio(void) const { return _deltaTimeRatio; }
    constexpr void setDeltaTime(f32 deltaTime) { _deltaTime = deltaTime; }
    constexpr void setDeltaTimeRatio(f32 deltaTimeRatio){ _deltaTimeRatio = deltaTimeRatio; }
    constexpr s32 getMotionNumber(void) const { return _motionNumber; }
    constexpr u32 getMotionNumberMin(void) const { return static_cast<s32>(GxModUnitMotionBase::MOTION_INDEX::BEGIN); }
    constexpr u32 getMotionNumberMax(void) const { return _pMotionPackageData[static_cast<s32>(GxModUnitMotionBase::MOTION_INDEX::SUM)] + static_cast<s32>(GxModUnitMotionBase::MOTION_INDEX::BASEPOSE); }
    u16 getMotionFrameCount(u32 motionNumber) const;
    GX_FORCE_INLINE u16 getMotionFrameCount(void) const { return getMotionFrameCount(_motionNumber);}
    GX_FORCE_INLINE f32 getFrameMax(void) const { return getFrameMax(_motionNumber);}
    GX_FORCE_INLINE f32 getFrameMax(u32 motionNumber) const { return static_cast<f32>(getMotionFrameCount(motionNumber) - 1.f);}
    b32 isFinish(void) const;       
    b32 isFinishNextFrame(void) const;
    b32 isLoopTiming(void) const;
    constexpr u32 getMotionCount(void) const { return _pMotionPackageData[static_cast<s32>(GxModUnitMotionBase::MOTION_INDEX::SUM)] - static_cast<s32>(GxModUnitMotionBase::MOTION_INDEX::BASEPOSE); }
    constexpr f32 getMotionRotateY(void) const { return _pMotionCurvesContainer ? _pMotionCurvesContainer->getMotionRotateY()   :  0.0f; }
    constexpr f32 getMotionTranslateY(void) const   { return _pMotionCurvesContainer ? _pMotionCurvesContainer->getMotionTranslateY() : 0.0f; }
    constexpr f32 getStartFrame(void) const { return _startFrame; }
 
    constexpr void setDecodeType(GxMotionCurvesContainerQuaternion::DECODE_TYPE type) { _decodeType = type; }
    GX_FORCE_INLINE void enableLinearInterpolation(b32 flag){ _enableInterpolation = flag; }
    void forceEnableLinearInterpolation(b32 flag);
 
#if GX_DEVELOP
    GX_FORCE_INLINE virtual GxMotionNamesList const& getMotionNamesList(void) const { return _motionNamesList; }
#endif //GX_DEVELOP
 
protected:
    constexpr u32 const* getMotionPackageData(void) const { return _pMotionPackageData; }   
    u32 const* getMotionData(s32 index) const;
    GX_FORCE_INLINE b32 isPlayDifferenceMotion(void){ return _isPlayDifferenceMotion;}
    GX_FORCE_INLINE void setPlayDifferenceMotion(b32 isPlayDifferenceMotion){ _isPlayDifferenceMotion = isPlayDifferenceMotion; }
public:
    constexpr GxResMotionPackage* getResMotionPackage(void) { return _pResMotionPackage; }
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public: 
    GX_FORCE_INLINE GxMotionJoint& getJointRaw(const u32 id) const { return _pJointArray[id]; }
    GxMotionJoint const* getJointArray(void) const;
    GxMotionJoint const* getJoint(const u32 id) const;
    GxMotionJoint* getJoint(const u32 id);
    constexpr s32 getJointCount(void) const { return _jointCount; }
    GX_FORCE_INLINE void getUpdateJoint(void* pValue, u32 index) { *static_cast<GxMotionJointData**>(pValue) = &_pJointArray[index]; }
    void updateJointMatricesNoIK(u32 jointStartNumber, u32 jointCount);
protected:
    constexpr GxIkChain* getIkChainArray(void) { return _pIkChainArray; }
    virtual void setTranslateRotateToJointArray(void);
    //note: 新モーションリソース用
    void setTranslateRotateQuatToOneJoint (GxMotionCurvesContainerQuaternion* pMotionCurvesContainerQuaternion ,u32 jointIndex);
    //note: 旧モーションリソース用
    f32 const* setTranslateRotateEulerToOneJoint(GxMotionJointData* pJointToSet, f32 const* pMotionDataReader, b32 isRootLocator);
public:
    GX_FORCE_INLINE b32 isJointArrayUpToDate(void) const { return _isJointLocalDataUpToDate; }
    GX_FORCE_INLINE void checkJointsLocalData(void) { if (!isJointArrayUpToDate()) { updateJointLocalData(); } }
 
    virtual void changeTransitionSettings(f32 transitionFrameNumber, INTERPOLATE interpolateType, f32 transitionCurvature);
    GX_FORCE_INLINE virtual void setInterpolateFrameNumber(f32 interpolateFrameNumber)  {  _interpolationSetting._frameNumber = interpolateFrameNumber;}
    GX_FORCE_INLINE virtual f32 getInterpolateFrameNumber(void) const { return _interpolationSetting._frameNumber; }
    GX_FORCE_INLINE virtual void setInterpolateType(INTERPOLATE interpolateType)  { _interpolationSetting._type = interpolateType;}
    GX_FORCE_INLINE virtual INTERPOLATE getInterpolateType(void)  { return _interpolationSetting._type;}
    GX_FORCE_INLINE virtual void setInterpolateCurvature(f32 interpolateCurvature) { _interpolationSetting._curvature = interpolateCurvature;}
    GX_FORCE_INLINE virtual f32 getInterpolateCurvature(void) const { return _interpolationSetting._curvature;}
    constexpr GxResMotionInterpolationSettings const* getInterpolationSettings(void) const { return _pResInterpSettings; }
    constexpr void setInterpolationSettings(GxResMotionInterpolationSettings const* pResInterpolateSettings) { _pResInterpSettings = pResInterpolateSettings; }
    GX_FORCE_INLINE f32 getInterpolationRatio(f32 frameElapsed) { return _interpolationSetting.getRatio(frameElapsed); }
 
public:
    constexpr GxIkChain const* getIkChainArray(void) const { return _pIkChainArray; }
    GX_FORCE_INLINE GxIkChain const* getIkChain(u32 index) const { return &_pIkChainArray[index]; } 
    GX_FORCE_INLINE GxIkChain* getIkChain(u32 index) { return &_pIkChainArray[index]; } 
    constexpr u32 getIkChainCount(void) const { return _ikChainCount; }
 
private:
    constexpr void getUpdateIkChain(void* pValue, u32 index) { *static_cast<GxIkChain**>(pValue)    = &_pIkChainArray[index]; }
    constexpr void getPropertyIkEffecterTarget(void* pValue, u32 index) { *static_cast<GxVector3**>(pValue) = &_pIkEffecterTargetArray[index]; }
    constexpr u32  getUpdateIkChainCount(void) { return static_cast<u32>(_updateIkChainCount);  }
    constexpr u32  getNoRootIkTargetCount(void) { return static_cast<u32>(_ikEffecterTargetCount); }
    GX_FORCE_INLINE void getPropertyFrame(void* pValue) { *static_cast<f32*>(pValue) = getFrame(); }
    GX_FORCE_INLINE void setPropertyFrame(const void* pValue) { setFrame(*static_cast<f32*>(const_cast<void*>(pValue))); }
    constexpr void getPropertyMotionNumber(void* pValue) { *static_cast<s32*>(pValue) = _motionNumber; }
    void setPropertyMotionNumber(const void* pValue);
 
public:
    GX_FORCE_INLINE GxJointDataArray* getInterpolationOriginArray(void) { return &_originDataArray; }
    constexpr void setInterpolateFrameElapsed(f32 value) { _interpolateFrameElapsed = value; }
 
protected:
    constexpr void setDummyValueIndex(const void* /*pValue*/, u32 /*index*/) {}
    constexpr void setDummySize(u32 /*index*/) {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxMotionJoint*          _pJointArray;               
    s32                     _jointCount;                
    s32                     _motionNumber;              
    f32                     _speed;                     
    u32                     _playbackFlags;             
    f32                     _deltaTime;                 
    f32                     _deltaTimeRatio;            
    GxResMotionPackage*     _pResMotionPackage;         
    u32 const*              _pMotionPackageData;        
    GxMotionCurvesContainer* _pMotionCurvesContainer;   
    b32                     _isJointLocalDataUpToDate;  
    f32                     _startFrame;                
    b32                     _isPlayDifferenceMotion;    
    s32                     _resourceVersion;           
    b32                     _enableInterpolation;       
#if GX_DEVELOP
    GxMotionNamesList       _motionNamesList;           
#endif //GX_DEVELOP
 
protected:
    s32                     _ikChainCount;              
    u32                     _updateIkChainCount;        
    u32                     _ikEffecterTargetCount;     
    GxVector3*              _pIkEffecterTargetArray;    
    GxIkChain*              _pIkChainArray;             
 
private:
    GxResMotionInterpolationSettings const* _pResInterpSettings;    
    GxInterpolationSetting  _interpolationSetting;      
protected:
    GxJointDataArray        _originDataArray;           
    GxJointDataArray        _interpolateDataArray;      
    b32                     _interpolatingMotion;       
    f32                     _interpolateFrameElapsed;   
    b32                     _isEnableInterpolateDataArray;  
 
    GxVector3               _rootPosition;              
private:
    b32                     _isPreviousFrameUpdateLoop; 
    GxMotionCurvesContainerQuaternion::DECODE_TYPE _decodeType; 
#if GX_DEVELOP
    GxGuiPropertySlider*    _pGuiFrame;                 
#endif
 
};
 
GX_MOTION_NAMESPACE_END()