GxUnitRealTimeDemo.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_UTILITY_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxUnitRealTimeDemo : public GxUnitLocate
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS_NAME_ICON(GxUnitRealTimeDemo, GxUnitLocate, "リアルタイムデモ基礎", GxRtti::ICON_TYPE::UNIT_MOVIE)
    // ClassBaseReference禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitRealTimeDemo)
 
    class GxReplaceUnit;
#if GX_DEVELOP
    friend class GxToolRealTimeDemo;
    friend class GxUnitRTDCharacter;
#endif //GX_DEVELOP
 
    static constexpr u32 RESOURCE_MAX = GxMath::VALUE_4;
private:
    enum class RESOURCE_LOAD_STATE
    {
        NO_REQUEST,         
        SYNC_LOAD_REQUEST,  
        ASYNC_LOAD_REQUEST, 
        ASYNC_LOADING,      
        LOAD_FINISHED,      
    };
 
public:
    enum class INTERPOLATE_TYPE
    {
        TRIGGER,                
        STEP,                   
        LINEAR,                 
        ADD_FRAME,              
        MAX,                    
        TYPE_RESERVED = 100,    
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(INTERPOLATE_TYPE)
#endif //GX_DEVELOP
 
    enum class END_FRAME_MODE
    {
        KEEP_UPDATE = 0,        
        DISABLE_RENDER,         
        OLD,                    
    };
 
#if GX_DEVELOP  
    enum SKIP_NOTIFICATION
    {
        SKIP_NOTIFICATION_NONE          = 0,            
        SKIP_NOTIFICATION_EFFECT        = 1 << 0,       
        SKIP_NOTIFICATION_RESERVED      = 1 << 1,       
        SKIP_NOTIFICATION_ALL           = 0xFFFFFFFF    
    };
 
    struct GxSkipNotification
    {
        SKIP_NOTIFICATION   _type;          
        u32                 _nowFrame;      
        u32                 _skipFrame;     
        GxString            _resourceName;  
    };
#endif //GX_DEVELOP
protected:
    class GxRtdUnit;
private:
    enum class PLAY_STATE
    {
        STOP = 0,   
        PAUSE,      
        PLAY,       
        PLAY_LOOP,  
    };
 
    enum class PLAY_REQUEST
    {
        NONE,       
        PLAY,       
        PLAY_LOOP,  
        PAUSE,      
        STOP,       
    };
 
    enum class SETUP_STATE
    {
        INITIALIZE,     
        LOADING,        
        LOAD_FINISHED,  
    };
 
    static const f32 INVALID_FRAME;
 
#if GX_DEVELOP
    enum SKIP
    {
        NONE,       
        REQUEST,    
        SETUP,      
        EXECUTE,    
        CLEANUP,    
    };
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxUnitRealTimeDemo(void);
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void asyncUpdate(void) override;
    void sequentialUpdate(void) override;
    void forceAsyncUpdate(void) override;
    virtual GxUnitRealTimeDemo::GxRtdUnit* createUnit(GxResRealTimeDemo::GxRtdUnit* pRtdUnit);
#if GX_DEVELOP
    void iconRender(void) override;
#endif //GX_DEVELOP
 
public:
    void play(f32 targetFrame = INVALID_FRAME);
    void playLoop(f32 targetFrame = INVALID_FRAME, s32 count = -1);
    void pause(void);
    void resume(void);
    void stop(void);
    void updateKeyFrame(void);
    b32 addReplaceUnit(s32 discrimID, GxUnitBase* pUnit);
    void clearReplaceUnit(void);
#if GX_DEVELOP
    GX_FORCE_INLINE virtual b32 requestEffectSkipCall(GxSkipNotification notification) { return true; }
#endif //GX_DEVELOP
protected:
    GX_FORCE_INLINE virtual void playCall(void){}
    GX_FORCE_INLINE virtual void stopCall(void){}
    GX_FORCE_INLINE virtual void preCreateUnitCall(void){}
    GX_FORCE_INLINE virtual void afterCreateUnitCall(void){}
 
#if GX_DEVELOP
public:
    s32  getNextKeyFrame(void);
    GX_FORCE_INLINE void requestSkip(void) { if (isPlaying() && _frameSkipState == SKIP::NONE) { _frameSkipState = SKIP::REQUEST; _skipTargetFrame = _targetFrame; } }
    virtual void skipEffect(GxUnitRealTimeDemo::GxRtdUnit* pUnit, u32 skipStartFrame, u32 skipEndFrame);
    virtual void setUnitSkipFrame(GxUnitRealTimeDemo::GxRtdUnit* pUnit, u32 unitSkipFrame);
    void skipRTDSub(u32 targetFrame);
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void setResourceAsync(GxResRealTimeDemo* pRes, u32 index, b32 loadKeyResourceAsync = true);
    constexpr GxResRealTimeDemo* getResource(u32 index) { return (index < RESOURCE_MAX) ? _pResource[index] : nullptr; }
 
    constexpr GxResRealTimeDemo* getRTDResource(u32 index){ return (index < RESOURCE_MAX) ? _pResource[index] : nullptr; }
    void setRTDResource(GxResRealTimeDemo* pRes, u32 index, b32 loadKeyResourceAsync = true);
    b32 isPlayable(void) const;
    b32 isPlaying(void) const;
    b32 _isPlaying(void) const;
    GX_FORCE_INLINE b32 isPausing(void) const { return _isPausing() || (_playRequest == PLAY_REQUEST::PAUSE); }
    GX_FORCE_INLINE b32 _isPausing(void) const { return _playState == PLAY_STATE::PAUSE; }
    f32 getNowFrame(void) const;
    f32 getStartFrame(void) const;
    f32 getEndFrame(void) const;
    GX_FORCE_INLINE b32 isScreenShot(void){ return _isScreenShot; }
    GX_FORCE_INLINE void setScreenShot(b32 on){ _isScreenShot = on; }
    void setPrecreateUnit(b32 enable);
    GxUnitBase* getUnit(u32 resourceIndex, u32 unitNodeId );
    GxUnitBase* getUnitFromDiscrimID(u32 resourceIndex, s32 discrimId);
    static b32 isSupport(GxProperty* pProperty);
    b32 getPropertyValueAsString(GxString& value, GxRtti*& pRtti, u32 resourceIndex, u32 unitNodeId, u32 propertyNodeId);
    b32 getPropertyValuePointer(GxTypedObject*& pValue, u32 resourceIndex, u32 unitNodeId, u32 targetPropertyNodeId);
    b32 getPropertyValuePointer(GxTypedObject*& pValue, u32 resourceIndex, GxResRealTimeDemo::GxRtdUnit* pUnit, u32 targetPropertyNodeId);
 
    void updatePlayState(void);
 
    constexpr void setEndFrameMode(END_FRAME_MODE mode) { _endFrameMode = mode; }
    constexpr END_FRAME_MODE getEndFrameMode(void) const { return _endFrameMode; }
 
    virtual b32 getKeyValueB32(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, b32& value);
    virtual b32 getKeyValueS32(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, s32& value);
    virtual b32 getKeyValueU32(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, u32& value);
    virtual b32 getKeyValueF32(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, f32& value);
    virtual b32 getKeyValueVector2(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, GxVector2& value);
    virtual b32 getKeyValueVector3(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, GxVector3& value);
    virtual b32 getKeyValueQuaternion(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, GxQuaternion& value);
    virtual b32 getKeyValueResource(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, GxClassBaseRoot*& value);
    virtual b32 getKeyValueColor(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, GxColor& value);
    virtual b32 getKeyValueColorHDR(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, GxColorHDR& value);
    virtual b32 getKeyValueEvent(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame);
    virtual b32 getKeyValueString(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, const GxTypedObject* pOwner, const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 bkFrame, GxString& value);
 
    GX_FORCE_INLINE const GxArrayClassBase* getReplaceUnitArray(void){ return &_replaceUnitArray; }
 
    GX_FORCE_INLINE static GxRtti* getRttiCreateCharacter(void){ return _pRttiCreateCharacter; }
    static constexpr void setRttiCreateCharacter(GxRtti* pRtti){ _pRttiCreateCharacter = pRtti; }
    GX_FORCE_INLINE static GxRtti* getRttiCreateCamera(void){ return _pRttiCreateCamera; }
    static constexpr void setRttiCreateCamera(GxRtti* pRtti){ _pRttiCreateCamera = pRtti; }
 
    GX_FORCE_INLINE void setCallbackStop(GxCallback::GxHandlerBase handler){ _callbackStop = handler; }
 
    GX_FORCE_INLINE void setForceSkipPlayMode(b32 enable) { _isForceSkipPlayMode = enable; }
    GX_FORCE_INLINE b32 isForceSkipPlayMode(void) const { return _isForceSkipPlayMode; }
 
#if GX_DEVELOP
    constexpr u32 getNowFrameU32(void) const { return static_cast<u32>(_nowFrame); }
    virtual void getInterpolateTypeEnum(GX_ENUM** ppEnum, u32* pCount);
    constexpr u32 getSkipFrame(void) const { return static_cast<u32>(_midFramePosition); }
    constexpr u32 getRequestSkipNotification(void) const { return _requestSkipNotification; }
    void setRequestSkipNotification(u32 skipRequest);
#endif //GX_DEVELOP
 
protected:
    virtual f32 getDeltaFrame(void);
    GX_FORCE_INLINE virtual b32 isSetupFinished(void){ return true; }
    GX_FORCE_INLINE GxArrayClassBase* getUnitArray(u32 index){ return &(_unitArray[index]); }
    b32 getPreviousNextKey(const GxResRealTimeDemo::GxRtdProp* pProperty, f32 nowFrame, f32 beforeFrame, GxResRealTimeDemo::GxRtdKeyBase*& pPreviousKey, GxResRealTimeDemo::GxRtdKeyBase*& pNextKey);
 
    virtual void pauseMotion(void);
    virtual void resumeMotion(void);
 
private:
    constexpr void getPropertyStartFrame(void* const pValue){ *static_cast<u32*>(pValue) = (nullptr != _pResource[0]) ? _pResource[0]->getStartFrame() : 0; }
    constexpr void setPropertyStartFrame(const void* const){}
    constexpr void getPropertyEndFrame(void* const pValue){ *static_cast<u32*>(pValue) = (nullptr != _pResource[0]) ? _pResource[0]->getEndFrame() : 0; }
    constexpr void setPropertyEndFrame(const void* const){}
    GX_FORCE_INLINE void getPropertyPlay(void* const pValue){ *static_cast<b32*>(pValue) = (PLAY_STATE::PLAY == _playState) || (PLAY_STATE::PLAY == _reservedPlayState); }
    void setPropertyPlay(const void* const pValue);
    GX_FORCE_INLINE void getPropertyPlayLoop(void* const pValue){ *static_cast<b32*>(pValue) = (PLAY_STATE::PLAY_LOOP == _playState) || (PLAY_STATE::PLAY_LOOP == _reservedPlayState); }
    void setPropertyPlayLoop(const void* const pValue);
    constexpr void getPropertyResource(void* const pValue, u32 index){ *static_cast<GxResRealTimeDemo**>(pValue) = _pResource[index]; }
    GX_FORCE_INLINE void setPropertyResource(const void* const pValue, u32 index){ setRTDResource(*static_cast<GxResRealTimeDemo**>(const_cast<void*>(pValue)), index, false); }
    constexpr u32 getPropertyResourceCount(void) const { return GxUnitRealTimeDemo::RESOURCE_MAX; }
    constexpr void setPropertyResourceCount(u32){}
    constexpr void getPropertyPreCreateUnit(void* const pValue){ *static_cast<b32*>(pValue) = _preCreateUnit; }
    GX_FORCE_INLINE void setPropertyPreCreateUnit(const void* const pValue){ setPrecreateUnit(*static_cast<b32*>(const_cast<void*>(pValue))); }
 
    GxUnitRealTimeDemo* getContinuePlayUnit(void);
    void setContinuePlayUnit(GxUnitRealTimeDemo* pContinuePlayUnit);
 
    void _play(b32 loop);
    void _stop(b32 resetFrame);
    void updateRtdPlay(void);
    void updatePlayStateAfter(void);
 
    void setSetupState(SETUP_STATE state);
    void updateSetupAsync(void);
    void updateSetupSeq(void);
    void loadKeyResource(u32 resourceIndex, GxSysResource::LOAD_MODE mode);
    void loadKeyResourceSub(GxSysResource::LOAD_MODE mode, GxArrayClassBase& keyResArray, GxResRealTimeDemo::GxRtdProp* pProperty);
    void releaseKeyResource(u32 resourceIndex);
    void releaseKeyResourceAll(void);
    b32 isLoadFinishedKeyResource(u32 resourceIndex);
 
    void setUpdateRenderUnit(b32 on);
    void createUnit(void);
    void updatePointerUnit(void);
    void disposeUnit(u32 resourceIndex);
    void disposeUnitAll(void);
    b32 isCreatedUnit(void);
 
    b32 getPropertyValueAsString(GxString& Value, GxRtti*& pRtti, GxTypedObject* pOwner, GxResRealTimeDemo::GxRtdProp* pProperty);
    b32 getPropertyValueAsStringSub(GxString& Value, GxRtti*& pRtti, u32 resourceIndex, u32 propertyNodeId, GxTypedObject* pOwner, GxResRealTimeDemo::GxRtdProp* pProperty);
    b32 getPropertyValuePointer(GxTypedObject*& pValue, GxResRealTimeDemo::GxRtdProp* pProperty, GxTypedObject* pOwner);
    b32 getPropertyValuePointerSub(GxTypedObject*& pValue, u32 propertyNodeId, u32 resourceIndex, GxResRealTimeDemo::GxRtdProp* pProperty, GxTypedObject* pOwner);
 
    void updateKeyFrameSub(const GxResRealTimeDemo::GxRtdUnit* pOwnerUnit, GxTypedObject* pOwner, GxResRealTimeDemo::GxRtdProp* pProperty);
 
    void updatePointerReplaceUnit(void);
 
    static s32 getPropertyIndex(GxResRealTimeDemo::GxRtdProp* pProperty);
 
    void registRenderUnit(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    f32                 _nowFrame;                      
    f32                 _beforeFrame;                   
    f32                 _deltaFrame;                    
    f32                 _targetFrame;                   
    s32                 _loopCount;                     
    PLAY_REQUEST        _playRequest;                   
    PLAY_STATE          _playState;                     
    PLAY_STATE          _reservedPlayState;             
    PLAY_STATE          _lastPlayState;                 
    b32                 _isResume;                      
    b32                 _isScreenShot;                  
    GxCriticalSection   _criticalSection;               
 
    GxUnitRealTimeDemo* _pContinuePlayUnit;             
    b32                 _continuePlayRequest;           
    f32                 _continuePlayWaitFrame;         
    f32                 _realNowFrame;                  
 
    SETUP_STATE         _setupState;                    
    GxResRealTimeDemo*  _pResource[RESOURCE_MAX];       
    RESOURCE_LOAD_STATE _resourceLoadState[RESOURCE_MAX];   
    GxArrayClassBase    _keyResourceArray[RESOURCE_MAX];
 
    b32                 _preCreateUnit;                 
    GxArrayClassBase    _unitArray[RESOURCE_MAX];       
    GxArrayClassBase    _replaceUnitArray;              
 
    GxUnitCameraBase*   _pUnitCamera;                   
    END_FRAME_MODE      _endFrameMode;                  
 
    static GxRtti*      _pRttiCreateCharacter;          
    static GxRtti*      _pRttiCreateCamera;             
 
    GxCallback::GxHandlerBase _callbackStop;            
 
    b32                 _isForceSkipPlayMode;           
 
#if GX_DEVELOP
    b32                 _isEnableDisposeUnitAll;        
    b32                 _isEnableFrameSkip;             
    u32                 _frameSkipState;                
    f32                 _previousDeltaTimeFactor;       
    f32                 _skipTargetFrame;               
    b32                 _isEnableMidFrameStart;         
    f32                 _midFramePosition;              
    u32                 _requestSkipNotification;       
protected:
    GxArray             _skipEffectList;                
    GxArray             _effectStartFrameList;          
#endif //GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxUnitRealTimeDemo::GxRtdUnit : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxUnitRealTimeDemo::GxRtdUnit, GxClassBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::UNIT)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    GxRtdUnit(void) : _pUnit(nullptr), _nodeId(0), _userData(""){};
    GxRtdUnit(u32 nodeId, GxRtti& rtti, GxString userData);
    GxRtdUnit(u32 nodeId, GxUnitBase* pUnit, GxString userData);
    ~GxRtdUnit(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    b32 updatePointer(void);
    void preserveReplacedUnitResource(void);
    void restoreReplacedUnitResource(void);
    void releaseReplacedUnitResource(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE b32 isReplacedUnit(void) const { return _isReplacedUnit; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxUnitBase*         _pUnit;                 
    u32                 _nodeId;                
    GxString            _userData;              
private:
    GxCriticalSection   _criticalSection;       
    b32                 _isReplacedUnit;        
    GxArrayClassBase    _replacedUnitResource;  
 
};
 
//===========================================================================
//===========================================================================
class GxUnitRealTimeDemo::GxReplaceUnit : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxUnitRealTimeDemo::GxReplaceUnit, GxClassBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::UNIT)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxReplaceUnit(void) : _discrimID(-1), _pUnit(nullptr){}
    GxReplaceUnit(s32 discrimID, GxUnitBase* pUnit) : _discrimID(discrimID), _pUnit(pUnit){}
    ~GxReplaceUnit(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    s32 _discrimID;         
    GxUnitBase* _pUnit;     
 
};
 
GX_UTILITY_NAMESPACE_END()