//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//

#ifndef LERP_FUNCTIONS_H
#define LERP_FUNCTIONS_H
#ifdef _WIN32
#pragma once
#endif

template <class T>
inline T LoopingLerp(float flPercent, T flFrom, T flTo) {
    T s = flTo * flPercent + flFrom * (1.0f - flPercent);
    return s;
}

template <>
inline float LoopingLerp(float flPercent, float flFrom, float flTo) {
    if (fabs(flTo - flFrom) >= 0.5f) {
        if (flFrom < flTo)
            flFrom += 1.0f;
        else
            flTo += 1.0f;
    }

    float s = flTo * flPercent + flFrom * (1.0f - flPercent);

    s = s - (int)(s);
    if (s < 0.0f) s = s + 1.0f;

    return s;
}

template <class T>
inline T Lerp_Hermite(float t, const T& p0, const T& p1, const T& p2) {
    T d1 = p1 - p0;
    T d2 = p2 - p1;

    T output;
    float tSqr = t * t;
    float tCube = t * tSqr;

    output = p1 * (2 * tCube - 3 * tSqr + 1);
    output += p2 * (-2 * tCube + 3 * tSqr);
    output += d1 * (tCube - 2 * tSqr + t);
    output += d2 * (tCube - tSqr);

    return output;
}

template <class T>
inline T Derivative_Hermite(float t, const T& p0, const T& p1, const T& p2) {
    T d1 = p1 - p0;
    T d2 = p2 - p1;

    T output;
    float tSqr = t * t;

    output = p1 * (6 * tSqr - 6 * t);
    output += p2 * (-6 * tSqr + 6 * t);
    output += d1 * (3 * tSqr - 4 * t + 1);
    output += d2 * (3 * tSqr - 2 * t);

    return output;
}

inline void Lerp_Clamp(int val) {}

inline void Lerp_Clamp(float val) {}

inline void Lerp_Clamp(const Vector& val) {}

inline void Lerp_Clamp(const QAngle& val) {}

// If we have a range checked var, then we can clamp to its limits.
template <class T, int minValue, int maxValue, int startValue>
inline void Lerp_Clamp(
    CRangeCheckedVar<T, minValue, maxValue, startValue>& val) {
    val.Clamp();
}

template <>
inline QAngle Lerp_Hermite<QAngle>(float t, const QAngle& p0, const QAngle& p1,
                                   const QAngle& p2) {
    // Can't do hermite with QAngles, get discontinuities, just do a regular
    // interpolation
    return Lerp(t, p1, p2);
}

template <class T>
inline T LoopingLerp_Hermite(float t, T p0, T p1, T p2) {
    return Lerp_Hermite(t, p0, p1, p2);
}

template <>
inline float LoopingLerp_Hermite(float t, float p0, float p1, float p2) {
    if (fabs(p1 - p0) > 0.5f) {
        if (p0 < p1)
            p0 += 1.0f;
        else
            p1 += 1.0f;
    }

    if (fabs(p2 - p1) > 0.5f) {
        if (p1 < p2) {
            p1 += 1.0f;

            // see if we need to fix up p0
            // important for vars that are decreasing from p0->p1->p2 where
            // p1 is fixed up relative to p2, eg p0 = 0.2, p1 = 0.1, p2 = 0.9
            if (abs(p1 - p0) > 0.5) {
                if (p0 < p1)
                    p0 += 1.0f;
                else
                    p1 += 1.0f;
            }
        } else {
            p2 += 1.0f;
        }
    }

    float s = Lerp_Hermite(t, p0, p1, p2);

    s = s - (int)(s);
    if (s < 0.0f) {
        s = s + 1.0f;
    }

    return s;
}

// NOTE: C_AnimationLayer has its own versions of these functions in
// animationlayer.h.

#endif  // LERP_FUNCTIONS_H