SlateSprings.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
template< typename FloatType >
class TSpring1D
{
 
public:
 
    class FSpringConfig
    {
 
    public:
 
        FloatType SpringConstant;
 
        FloatType SpringLength;
 
        FloatType DampConstant;
 
        FloatType SnappingEpsilon;
 
        bool bSkipAnimationOnHitches;
 
 
        FSpringConfig()
            : SpringConstant( FloatType( 20.0 ) ),
              SpringLength( FloatType( 0.0 ) ),
              DampConstant( FloatType( 0.5 ) ),
              SnappingEpsilon( FloatType( 0.01 ) ),
              bSkipAnimationOnHitches( true )
        {
        }
    };
 
 
 
    TSpring1D()
        : Position( 0.0 ),
          Target( 0.0 ),
          PreviousTarget( 0.0 )
    {
    }
 
 
    TSpring1D( FloatType InPosition )
        : Position( InPosition ),
          Target( InPosition ),
          PreviousTarget( InPosition )
    {
    }
 
 
    void SetConfig( const FSpringConfig& InConfig )
    {
        Config = InConfig;
    }
 
 
    void SetPosition( FloatType InPosition )
    {
        Position = InPosition;
        Target = InPosition;
        PreviousTarget = InPosition;
    }
 
    
    FloatType GetPosition() const
    {
        return Position;
    }
 
 
    void SetTarget( FloatType InTarget )
    {
        Target = InTarget;
    }
 
    
    FloatType GetTarget() const
    {
        return Target;
    }
 
    bool IsAtRest()
    {
        return Target == Position;
    }
 
    void Tick( float InQuantum )
    {
        const float MaxQuantum = 1.0f / 8.0f;
        if( InQuantum > MaxQuantum )
        {
            // If we are configured to reset the spring's state to the new position immediately upon
            // a hitch, then we'll do that now.
            if( Config.bSkipAnimationOnHitches )
            {
                Position = PreviousTarget = Target;
            }
            else
            {
                // Not asked to reset on large quantums, so we'll instead clamp the quantum so that
                // the spring does not behave erratically. (slow motion)
                InQuantum = MaxQuantum;
            }
        }
 
        const FloatType Disp = Target - Position;
        const FloatType DispLength = FMath::Abs( Disp );
        if( DispLength > Config.SnappingEpsilon )
        {
            const FloatType ForceDirection = Disp >= 0.0f ? 1.0f : -1.0f;
            const FloatType TargetDisp = Target - PreviousTarget;
            const FloatType VelocityOfTarget = TargetDisp * InQuantum;
            const FloatType DistBetweenDisplacements = FMath::Abs( Disp - VelocityOfTarget );
 
            const FloatType ForceAmount =
                Config.SpringConstant * FMath::Max< FloatType >( 0.0, DispLength - Config.SpringLength ) +
                Config.DampConstant * DistBetweenDisplacements;
 
            // We use Min here to prevent overshoots
            Position += ForceDirection * FMath::Min( DispLength, ForceAmount * InQuantum );
        }
 
        // Snap new position to target if we're close enough
        if( FMath::Abs( Position - Target ) < Config.SnappingEpsilon )
        {
            Position = Target;
        }
 
        PreviousTarget = Target;
    }
 
private:
 
    FSpringConfig Config;
 
    FloatType Position;
 
    FloatType Target;
 
    FloatType PreviousTarget;
 
};
 
typedef TSpring1D<float> FFloatSpring1D;
 
typedef TSpring1D<double> FDoubleSpring1D;