GxModUnitCurvePlay.h

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxCurvePlay;
class GxResCurveKey;
#if GX_DEVELOP
class GxGuiButton;
class GxGuiPropertySlider;
class GxGuiPropertyComboBoxEnum;
#endif // GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxModUnitCurvePlayList : public GxModUnitBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS_NAME(GxModUnitCurvePlayList, GxModUnitBase, "カーブ再生")
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxModUnitCurvePlayList)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxModUnitCurvePlayList(void);
    ~GxModUnitCurvePlayList( void ) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    b32 setup( void ) override;
 
public:
    GxCurvePlay* createAndAddBottom( void );
    void removeAll( void );
 
    void asyncUpdate( void ) override;
 
    void playAll( b32 isReverse = false );
    void stopAll( void );
 
private:
    void propertyAddListCallback( GxClassBaseRoot* pValue );
 
protected:
#if GX_DEVELOP
    static GxGuiBase* createGui( GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index );
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE GxCurvePlay* getCurvePlay(u32 index) { GX_ASSERT(index < _array.getCount(), "index over"); return reinterpret_cast<GxCurvePlay*>(_array[index]); }
    constexpr u32 getArrayCount( void ) { return _array.getCount(); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxArrayClassBase            _array;                         
 
};
 
//===========================================================================
//===========================================================================
class GxCurve : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxCurve, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxCurve)
 
    
    enum class EASING_TYPE
    {
        LINEAR,             
        IN_SIGN,            
        OUT_SIGN,           
        INOUT_SIGN,         
        IN_QUAD,            
        OUT_QUAD,           
        INOUT_QUAD,         
        IN_CUBIC,           
        OUT_CUBIC,          
        INOUT_CUBIC,        
        IN_QUART,           
        OUT_QUART,          
        INOUT_QUART,        
        IN_QUINT,           
        OUT_QUINT,          
        INOUT_QUINT,        
        IN_EXPO,            
        OUT_EXPO,           
        INOUT_EXPO,         
        IN_CIRC,            
        OUT_CIRC,           
        INOUT_CIRC,         
        IN_BACK,            
        OUT_BACK,           
        INOUT_BACK,         
        IN_ELASTIC,         
        OUT_ELASTIC,        
        INOUT_ELASTIC,      
        IN_BOUNCE,          
        OUT_BOUNCE,         
        INOUT_BOUNCE,       
        MAX,                
    };
#if GX_DEVELOP
    GX_ENUM_TABLE(EASING_TYPE)
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxCurve( void );
 
    ~GxCurve( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    f32 getValue( f32 duration, f32 currentDuration );
 
protected:
    void getPropertyCurvePlayResource( void* const pValue );
    void setPropertyCurvePlayResource( const void* const pValue );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr EASING_TYPE getEasingType( void )             const   { return _easingType; }
    constexpr void setEasingType( const EASING_TYPE easingType )    { _easingType = easingType; }
    constexpr GxResCurveKey* getCurveKeyResource( void )            { return _pResCurveKey; }
    constexpr void setCurveKeyResource(GxResCurveKey* pRes )        { _pResCurveKey = pRes; }
    constexpr f32 getScaleFactorValue( void )               const   { return _scaleFactorValue; }
    constexpr void setScaleFactorValue( f32 value )                 { _scaleFactorValue = value; }
    constexpr f32 getOffsetValue( void )                    const   { return _offsetValue; }
    constexpr void setOffsetValue( f32 value )                      { _offsetValue = value; }
 
#if GX_DEVELOP
    constexpr GxGuiPropertyComboBoxEnum* getGuiEasingType( void )   { return _pGuiEasingType; }
#endif // GX_DEVELOP
 
private:
    constexpr f32 getEasingFactorValue1( void )         const   { return 1.70158f; }
    constexpr f32 getEasingFactorValue2( void )         const   { return getEasingFactorValue1() * 1.525f; }
    constexpr f32 getEasingFactorValue3( void )         const   { return getEasingFactorValue1() + 1.f; }
    constexpr f32 getEasingFactorValue4( void )         const   { return (2.f * PI) / 3.f; }
    constexpr f32 getEasingFactorValue5( void )         const   { return (2.f * PI) / 4.5f; }
 
    GX_FORCE_INLINE f32 getValueInSine( f32 time )          const   { return 1.f - GxMath::getCos((time * PI) / 2.f); }
    GX_FORCE_INLINE f32 getValueOutSine( f32 time )         const   { return GxMath::getSin((time * PI) / 2.f); }
    GX_FORCE_INLINE f32 getValueInOutSine( f32 time )       const   { return -(GxMath::getCos(PI * time) - 1.f) / 2.f; }
    constexpr f32 getValueInQuad( f32 time )                const   { return time * time; }
    constexpr f32 getValueOutQuad( f32 time )               const   { return 1.f - (1.f - time) * (1.f - time); }
    GX_FORCE_INLINE f32 getValueInOutQuad( f32 time )       const   { return time < 0.5f ? 2.f * time * time : 1 - GxMath::getPow(-2.f * time + 2.f, 2.f) / 2.f; }
    constexpr f32 getValueInCubic( f32 time )               const   { return time * time * time; }
    GX_FORCE_INLINE f32 getValueOutCubic( f32 time )        const   { return 1.f - GxMath::getPow(1.f - time, 3.f); }
    GX_FORCE_INLINE f32 getValueInOutCubic( f32 time )      const   { return time < 0.5f ? 4.f * time * time * time : 1.f - GxMath::getPow(-2.f * time + 2.f, 3.f) / 2.f; }
    constexpr f32 getValueInQuart( f32 time )               const   { return time * time * time * time; }
    GX_FORCE_INLINE f32 getValueOutQuart( f32 time )        const   { return 1.f - GxMath::getPow(1.f - time, 4.f); }
    GX_FORCE_INLINE f32 getValueInOutQuart( f32 time )      const   { return time < 0.5f ? 8.f * time * time * time * time : 1.f - GxMath::getPow(-2.f * time + 2.f, 4.f) / 2.f; }
    constexpr f32 getValueInQuint( f32 time )               const   { return time * time * time * time; }
    GX_FORCE_INLINE f32 getValueOutQuint( f32 time )        const   { return 1.f - GxMath::getPow(1.f - time, 5.f); }
    GX_FORCE_INLINE f32 getValueInOutQuint( f32 time )      const   { return time < 0.5f ? 16.f * time * time * time * time * time : 1.f - GxMath::getPow(-2.f * time + 2.f, 5.f) / 2; }
    GX_FORCE_INLINE f32 getValueInExpo( f32 time )          const   { return time == 0.f ? 0.f : GxMath::getPow(2.f, 10.f * time - 10.f); }
    GX_FORCE_INLINE f32 getValueOutExpo( f32 time )         const   { return time == 1.f ? 1.f : 1.f - GxMath::getPow(2.f, -10.f * time); }
    f32 getValueInOutExpo(f32 time) const;
    GX_FORCE_INLINE f32 getValueInCirc( f32 time )              const   { return 1.f - GxMath::getSqrt(1.f - GxMath::getPow(time, 2.f)); }
    GX_FORCE_INLINE f32 getValueOutCirc( f32 time )             const   { return GxMath::getSqrt(1.f - GxMath::getPow(time - 1.f, 2.f)); }
    GX_FORCE_INLINE f32 getValueInOutCirc( f32 time )           const   { return time < 0.5 ? (1.f - GxMath::getSqrt(1.f - GxMath::getPow(2.f * time, 2.f))) / 2.f : (GxMath::getSqrt(1.f - GxMath::getPow(-2.f * time + 2.f, 2.f)) + 1.f) / 2.f; }
    constexpr f32 getValueInBack( f32 time )                    const   { return getEasingFactorValue3() * time * time * time - getEasingFactorValue1() * time * time; }
    GX_FORCE_INLINE f32 getValueOutBack( f32 time )             const   { return 1.f + getEasingFactorValue3() * GxMath::getPow(time - 1.f, 3.f) + getEasingFactorValue1() * GxMath::getPow(time - 1.f, 2.f); }
    GX_FORCE_INLINE f32 getValueInOutBack( f32 time )           const   { return time < 0.5f ? (GxMath::getPow(2.f * time, 2.f) * ((getEasingFactorValue2() + 1.f) * 2.f * time - getEasingFactorValue2())) / 2.f : (GxMath::getPow(2.f * time - 2.f, 2.f) * ((getEasingFactorValue2() + 1.f) * (time * 2.f - 2.f) + getEasingFactorValue2()) + 2.f) / 2.f; }
    f32 getValueInElastic(f32 time) const;
    f32 getValueOutElastic(f32 time) const;
    f32 getValueInOutElastic(f32 time) const;
    GX_FORCE_INLINE f32 getValueInBounce( f32 time )            const   { return 1.f - getValueOutBounce(1.f - time); }
    f32 getValueOutBounce(f32 time) const;
    GX_FORCE_INLINE f32 getValueInOutBounce( f32 time )         const   { return time < 0.5f ? (1.f - getValueOutBounce(1.f - 2.f * time)) / 2.f : (1.f + getValueOutBounce(2.f * time - 1.f)) / 2.f; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    EASING_TYPE                     _easingType;                
    GxResCurveKey*                  _pResCurveKey;              
 
    f32                             _scaleFactorValue;          
    f32                             _offsetValue;               
 
#if GX_DEVELOP
    GxGuiPropertyComboBoxEnum*              _pGuiEasingType;            
#endif // GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxCurvePlay : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxCurvePlay, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxCurvePlay)
 
    
    enum class PLAY_STATE
    {
        PLAY,               
        STOP,               
        PAUSE,              
        MAX,                
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(PLAY_STATE)
#endif //GX_DEVELOP
 
    enum class LOOP_TYPE
    {
        NONE,               
        YOYO,               
        RESTART,            
        MAX,                
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(LOOP_TYPE)
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxCurvePlay( void );
 
    ~GxCurvePlay(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void setPlayF32( GxTypedObject* pOwner, GxProperty* pProperty, f32 endValue, f32 duration, f32 delay = 0.f, b32 isAutoPlay = true, LOOP_TYPE loopType = LOOP_TYPE::NONE );
    void setPlayVector2( GxTypedObject* pOwner, GxProperty* pProperty, const GxVector2& endValue, f32 duration, f32 delay = 0.f, b32 isAutoPlay = true, LOOP_TYPE loopType = LOOP_TYPE::NONE );
    void setPlayVector3( GxTypedObject* pOwner, GxProperty* pProperty, const GxVector3& endValue, f32 duration, f32 delay = 0.f, b32 isAutoPlay = true, LOOP_TYPE loopType = LOOP_TYPE::NONE );
    void setPlayVector4( GxTypedObject* pOwner, GxProperty* pProperty, const GxVector4& endValue, f32 duration, f32 delay = 0.f, b32 isAutoPlay = true, LOOP_TYPE loopType = LOOP_TYPE::NONE );
    void setPlayColor( GxTypedObject* pOwner, GxProperty* pProperty, const GxColor& endValue, f32 duration, f32 delay = 0.f, b32 isAutoPlay = true, LOOP_TYPE loopType = LOOP_TYPE::NONE );
    void setPlayColorHDR( GxTypedObject* pOwner, GxProperty* pProperty, const GxColorHDR& endValue, f32 duration, f32 delay = 0.f, b32 isAutoPlay = true, LOOP_TYPE loopType = LOOP_TYPE::NONE );
 
    void update( f32 deltaTime );
 
    void play( b32 isReverse = false );
    void playDurationRate( b32 isReverse, f32 durationRate );
    void stop( void );
    void pause( void );
 
private:
    void setPlayInner( GxTypedObject* pOwner, GxProperty* pProperty, f32 duration, f32 delay, b32 isAutoPlay, LOOP_TYPE loopType );
    void playInner( void );
 
    void propertySelectCallback( GxProperty* pProperty, GxProperty* pChildProperty );
 
protected:
#if GX_DEVELOP
    static GxGuiBase* createGui( GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index );
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE b32 isPlayState(PLAY_STATE state) const { return _playState == state; }
 
    GX_FORCE_INLINE const GxCurve& getCurve( void )     const   { return _curve; }
 
    constexpr void setOwner( GxTypedObject* pOwner )            { _pOwner = pOwner; }
 
    constexpr LOOP_TYPE getLoopType( void   )           const   { return _loopType; }
    constexpr void setLoopType( const LOOP_TYPE loopType )      { _loopType = loopType; }
    constexpr f32 getDelay( void )                      const   { return _delay; }
    constexpr void setDelay( const f32 delay )                  { _delay = delay; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxCurve                     _curve;                         
    LOOP_TYPE                   _loopType;                      
    f32                         _duration;                      
    f32                         _delay;                         
    f32                         _playDurationRate;              
 
    f32                         _oldDuration;                   
    f32                         _oldDelay;                      
    f32                         _currentDuration;               
    f32                         _currentDelay;                  
 
    GxProperty*                 _pProperty;                     
    GxProperty*                 _pChildProperty;                
    GxTypedObject*              _pOwner;                        
 
    b32                         _isUseCurveStartEnd;            
    f32                         _startF32;                      
    f32                         _endF32;                        
    GxVector2                   _startVector2;                  
    GxVector2                   _endVector2;                    
    GxVector3                   _startVector3;                  
    GxVector3                   _endVector3;                    
    GxVector4                   _startVector4;                  
    GxVector4                   _endVector4;                    
    GxColor                     _startColor;                    
    GxColor                     _endColor;                      
    GxColorHDR                  _startColorHDR;                 
    GxColorHDR                  _endColorHDR;                   
 
    b32                         _isReverse;                     
    PLAY_STATE                  _playState;                     
 
#if GX_DEVELOP
    GxGuiPropertySlider*        _pGuiCurrentDuration;           
    GxGuiButton*                _pGuiPlay;                      
    GxGuiButton*                _pGuiPause;                     
#endif // GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxCurveKey : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxCurveKey, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxCurveKey)
 
    
    enum class CURVE_TYPE
    {
        FREE,       
        LINEAR,     
        CONSTANT,   
        MAX,        
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(CURVE_TYPE)
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxCurveKey( void );
    GxCurveKey( f32 value, f32 time );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void setTime(f32 time);
    void setValue( f32 value );
    void setHandleRenderScale( f32 scaleX, f32 scaleY );
    void setHandleRotationValue( f32 value );
 
private:
    void updateHandlePosition( void );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr f32 getTime(void)                                             const { return _time; }
    constexpr f32 getValue( void )                                              const   { return _value; }
    GX_FORCE_INLINE const GxVector2& getHandleStartPosition( void )             const   { return _handleStartPosition; }
    GX_FORCE_INLINE const GxVector2& getHandleEndPosition( void )               const   { return _handleEndPosition; }
    constexpr CURVE_TYPE getCurveType(void)                                   const { return _curveType; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    f32                             _time;                      
    f32                             _value;                     
    f32                             _handleRotationValue;       
    GxVector2                       _handleRenderScale;         
    GxVector2                       _handleStartPosition;       
    GxVector2                       _handleEndPosition;         
    CURVE_TYPE                      _curveType;                 
 
};
 
GX_CORE_NAMESPACE_END()