bezierInterpolator.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
#pragma once
 
//! \file bezierInterpolator.h
//! \brief Provides a template class for Bezier curve-based interpolation
 
#include <vrvUtil/DtEaser.h>
 
namespace makVre
{
//! \brief Bezier curve-based interpolation template class
//!
//! This template class provides interpolation between start and end values
//! using Bezier curves for easing over a specified time period.
//! Specializations are provided for float, double, DtVector, and DtQuat types.
//!
//! \tparam T The type of value to interpolate
template <typename T>
class DtBezierInterpolator
{
public:
   //! \brief Constructor
   //!
   //! Initializes the interpolator with an easing function, start and end values,
   //! and the time period.
   //!
   //! \param easer The easing function to use for interpolation
   //! \param start The starting value
   //! \param stop The ending value
   //! \param period The time period over which to interpolate (in seconds)
   DtBezierInterpolator(makVrv::DtEaser easer, T start, T stop, double period);
 
   //! \brief Destructor
   ~DtBezierInterpolator();
 
   //! \brief Updates the interpolation based on elapsed time
   //!
   //! This function advances the interpolation by the given time step,
   //! recalculating the current value based on the elapsed time and easing function.
   //! Specialized implementations are provided for float, double, DtVector, and DtQuat.
   //!
   //! \param dt The time step in seconds
   void tick(double dt);
 
   //! \brief Gets the current interpolated value
   //!
   //! \return The current value of the interpolation
   T value() const;
 
   //! \brief Checks if the interpolation has completed
   //!
   //! \return true if the current time has reached or exceeded the period
   bool isDone() const;
 
   //! \brief Resets the interpolation to the beginning
   //!
   //! Sets the current value back to the start value and resets the time to zero
   void reset();
 
   //! \brief Resets the interpolation with new start, end, and period values
   //!
   //! \param start The new starting value
   //! \param stop The new ending value
   //! \param period The new time period (in seconds)
   void reset(T start, T stop, double period);
 
   //! \brief Resets the interpolation with a new easer and parameters
   //!
   //! \param easer The new easing function
   //! \param start The new starting value
   //! \param stop The new ending value
   //! \param period The new time period (in seconds)
   void reset(makVrv::DtEaser easer, T start, T stop, double period);
 
   //! \brief Gets the start value
   //!
   //! \return The start value of the interpolation
   T start() const;
 
   //! \brief Gets the end value
   //!
   //! \return The end value of the interpolation
   T stop() const;
 
   //! \brief Gets the time remaining in the interpolation
   //!
   //! \return The remaining time in seconds
   double timeRemaining() const;
 
protected:
   //! \brief The easing function to use
   makVrv::DtEaser myEaser;
 
   //! \brief The starting value
   T myStart;
 
   //! \brief The ending value
   T myEnd;
 
   //! \brief The current interpolated value
   T myCurrentValue;
 
   //! \brief The total time period for the interpolation (in seconds)
   double myPeriod;
 
   //! \brief The current elapsed time (in seconds)
   double myCurrentTime;
};
 
// Implementation
 
//! \brief Constructor implementation
template <typename T>
makVre::DtBezierInterpolator<T>::DtBezierInterpolator(makVrv::DtEaser easer, T start, T stop, double period)
   : myEaser(easer)
   , myStart(start)
   , myEnd(stop)
   , myCurrentValue(start)
   , myCurrentTime(0)
   , myPeriod(period)
{
}
 
//! \brief Destructor implementation
template <typename T>
makVre::DtBezierInterpolator<T>::~DtBezierInterpolator()
{
}
 
//! \brief Gets the current value of the interpolation
template <typename T>
T makVre::DtBezierInterpolator<T>::value() const
{
   return myCurrentValue;
}
 
//! \brief Gets the start value of the interpolation
template <typename T>
T makVre::DtBezierInterpolator<T>::start() const
{
   return myStart;
}
 
//! \brief Gets the end value of the interpolation
template <typename T>
T makVre::DtBezierInterpolator<T>::stop() const
{
   return myEnd;
}
 
//! \brief Gets the time remaining in the interpolation
template <typename T>
double makVre::DtBezierInterpolator<T>::timeRemaining() const
{
   return myPeriod - myCurrentTime;
}
 
//! \brief Checks if the interpolation has completed
template <typename T>
bool DtBezierInterpolator<T>::isDone() const
{
   return myCurrentTime >= myPeriod;
}
 
//! \brief Resets the interpolation to the beginning
template <typename T>
void DtBezierInterpolator<T>::reset()
{
   myCurrentValue = myStart;
   myCurrentTime = 0.0;
}
 
//! \brief Resets the interpolation with new parameters
template <typename T>
void DtBezierInterpolator<T>::reset(T start, T stop, double period)
{
   myStart = start;
   myEnd = stop;
   myPeriod = period;
   myCurrentValue = myStart;
   myCurrentTime = 0.0;
}
 
//! \brief Resets the interpolation with a new easer and parameters
template <typename T>
void makVre::DtBezierInterpolator<T>::reset(makVrv::DtEaser easer, T start, T stop, double period)
{
   myEaser = easer;
   myStart = start;
   myEnd = stop;
   myPeriod = period;
   myCurrentValue = myStart;
   myCurrentTime = 0.0;
}
 
//! \brief Namespace containing predefined easing functions
//!
//! This namespace provides a collection of standard easing functions
//! for use with the DtBezierInterpolator class. Each function returns
//! a properly configured DtEaser object for a specific easing type.
namespace Eases
{
//! \brief Creates an ease-in sine function
//! \return A DtEaser configured for sine ease-in
static makVrv::DtEaser EaseInSine()
{
   return makVrv::DtEaser(0.12f, 0.f, 0.39f, 0.f);
};
 
//! \brief Creates an ease-out sine function
//! \return A DtEaser configured for sine ease-out
static makVrv::DtEaser EaseOutSine()
{
   return makVrv::DtEaser(0.61f, 1.f, 0.88f, 1.f);
};
 
//! \brief Creates an ease-in-out sine function
//! \return A DtEaser configured for sine ease-in-out
static makVrv::DtEaser EaseInOutSine()
{
   return makVrv::DtEaser(0.37f, 0.f, 0.63f, 1.f);
};
 
//! \brief Creates an ease-in quadratic function
//! \return A DtEaser configured for quadratic ease-in
static makVrv::DtEaser EaseInQuad()
{
   return makVrv::DtEaser(0.11f, 0.f, 0.5f, 0.f);
};
 
//! \brief Creates an ease-out quadratic function
//! \return A DtEaser configured for quadratic ease-out
static makVrv::DtEaser EaseOutQuad()
{
   return makVrv::DtEaser(0.5f, 1.f, 0.89f, 1.f);
};
 
//! \brief Creates an ease-in-out quadratic function
//! \return A DtEaser configured for quadratic ease-in-out
static makVrv::DtEaser EaseInOutQuad()
{
   return makVrv::DtEaser(0.45f, 0.f, 0.55f, 1.f);
};
 
//! \brief Creates an ease-in cubic function
//! \return A DtEaser configured for cubic ease-in
static makVrv::DtEaser EaseInCubic()
{
   return makVrv::DtEaser(0.32f, 0.f, 0.67f, 0.f);
};
 
//! \brief Creates an ease-out cubic function
//! \return A DtEaser configured for cubic ease-out
static makVrv::DtEaser EaseOutCubic()
{
   return makVrv::DtEaser(0.33f, 1.f, 0.68f, 1.f);
};
 
//! \brief Creates an ease-in-out cubic function
//! \return A DtEaser configured for cubic ease-in-out
static makVrv::DtEaser EaseInOutCubic()
{
   return makVrv::DtEaser(0.65f, 0.f, 0.35f, 1.f);
};
 
//! \brief Creates an ease-in quartic function
//! \return A DtEaser configured for quartic ease-in
static makVrv::DtEaser EaseInQuart()
{
   return makVrv::DtEaser(0.5f, 0.f, 0.75f, 0.f);
};
 
//! \brief Creates an ease-out quartic function
//! \return A DtEaser configured for quartic ease-out
static makVrv::DtEaser EaseOutQuart()
{
   return makVrv::DtEaser(0.25f, 1.f, 0.5f, 1.f);
};
 
//! \brief Creates an ease-in-out quartic function
//! \return A DtEaser configured for quartic ease-in-out
static makVrv::DtEaser EaseInOutQuart()
{
   return makVrv::DtEaser(0.76f, 0.f, 0.24f, 1.f);
};
 
//! \brief Creates an ease-in quintic function
//! \return A DtEaser configured for quintic ease-in
static makVrv::DtEaser EaseInQuint()
{
   return makVrv::DtEaser(0.64f, 0.f, 0.78f, 0.f);
};
 
//! \brief Creates an ease-out quintic function
//! \return A DtEaser configured for quintic ease-out
static makVrv::DtEaser EaseOutQuint()
{
   return makVrv::DtEaser(0.22f, 1.f, 0.36f, 1.f);
};
 
//! \brief Creates an ease-in-out quintic function
//! \return A DtEaser configured for quintic ease-in-out
static makVrv::DtEaser EaseInOutQuint()
{
   return makVrv::DtEaser(0.83f, 0.f, 0.17f, 1.f);
};
 
//! \brief Creates an ease-in exponential function
//! \return A DtEaser configured for exponential ease-in
static makVrv::DtEaser EaseInExpo()
{
   return makVrv::DtEaser(0.7f, 0.f, 0.84f, 0.f);
};
 
//! \brief Creates an ease-out exponential function
//! \return A DtEaser configured for exponential ease-out
static makVrv::DtEaser EaseOutExpo()
{
   return makVrv::DtEaser(0.16f, 1.f, 0.3f, 1.f);
};
 
//! \brief Creates an ease-in-out exponential function
//! \return A DtEaser configured for exponential ease-in-out
static makVrv::DtEaser EaseInOutExpo()
{
   return makVrv::DtEaser(0.87f, 0.f, 0.13f, 1.f);
};
 
//! \brief Creates an ease-in circular function
//! \return A DtEaser configured for circular ease-in
static makVrv::DtEaser EaseInCirc()
{
   return makVrv::DtEaser(0.55f, 0.f, 1.f, 0.45f);
};
 
//! \brief Creates an ease-out circular function
//! \return A DtEaser configured for circular ease-out
static makVrv::DtEaser EaseOutCirc()
{
   return makVrv::DtEaser(0.f, 0.55f, 0.45f, 1.f);
};
 
//! \brief Creates an ease-in-out circular function
//! \return A DtEaser configured for circular ease-in-out
static makVrv::DtEaser EaseInOutCirc()
{
   return makVrv::DtEaser(0.85f, 0.f, 0.15f, 1.f);
};
 
//! \brief Creates an ease-in back function (overshoots backwards)
//! \return A DtEaser configured for back ease-in
static makVrv::DtEaser EaseInBack()
{
   return makVrv::DtEaser(0.36f, 0.f, 0.66f, -0.56f);
};
 
//! \brief Creates an ease-out back function (overshoots forwards)
//! \return A DtEaser configured for back ease-out
static makVrv::DtEaser EaseOutBack()
{
   return makVrv::DtEaser(0.34f, 1.56f, 0.64f, 1.f);
};
 
//! \brief Creates an ease-in-out back function (overshoots both ways)
//! \return A DtEaser configured for back ease-in-out
static makVrv::DtEaser EaseInOutBack()
{
   return makVrv::DtEaser(0.68f, -0.6f, 0.32f, 1.6f);
};
} // namespace Eases
} // namespace makVre