Lerp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
#pragma once
 
#include "Misc.h"
#include <concepts>
 
namespace pongasoft::Utils {

template<typename T, typename X, typename Y>
concept HasStaticMapValue =
  requires(X value, X from, X to, Y outFrom, Y outTo, bool clamp)
{
  { T::mapValue(value, from, to, outFrom, outTo, clamp) } -> std::convertible_to<Y>;
};

template <typename TFloat, typename X, typename Y>
class Lerp
{
public:
  constexpr Lerp(X iX1, Y iY1, X iX2, Y iY2) noexcept :
    fA((static_cast<TFloat>(iY1 - iY2)) / (static_cast<TFloat>(iX1 - iX2))),
    fB(static_cast<TFloat>(iY1) - fA * static_cast<TFloat>(iX1)) {}

  constexpr Lerp(Y iY0, Y iY1) noexcept : fA(static_cast<TFloat>(iY1 - iY0)), fB(static_cast<TFloat>(iY0)) {};
 
  constexpr Y computeY(X iX) const
  {
    return static_cast<Y>((static_cast<TFloat>(iX) * fA) + fB);
  }
 
  constexpr X computeX(Y iY) const
  {
    DCHECK_F(fA != 0);
    return static_cast<X>((static_cast<TFloat>(iY) - fB) / fA);
  }

  static constexpr Lerp mapRange(X iFromLow, X iFromHigh, Y iToLow, Y iToHigh) noexcept
  {
    return Lerp(iFromLow, iToLow, iFromHigh, iToHigh);
  }

  static constexpr Y mapValue(X iValue, X iFromLow, X iFromHigh, Y iToLow, Y iToHigh, bool iClamp = true)
  {
    // if the first range is empty (computation would be dividing by 0)
    if(iFromLow == iFromHigh)
      return iValue <= iFromLow ? iToLow : iToHigh;
 
    // if the second range is empty, no need for computation
    if(iToLow == iToHigh)
      return iToLow;
 
    if(iClamp)
    {
      iValue = clampRange(iValue, iFromLow, iFromHigh);
    }
 
    return Lerp(iFromLow, iToLow, iFromHigh, iToHigh).computeY(iValue);
  }
 
private:
  const TFloat fA;
  const TFloat fB;
};
 
//------------------------------------------------------------------------
// SPLerp - Single Precision Lerp (float)
//------------------------------------------------------------------------
template<typename X, typename Y>
using SPLerpXY = Lerp<float, X, Y>;
 
template<typename X>
using SPLerpX = Lerp<float, X, float>;
 
template<typename Y>
using SPLerpY = Lerp<float, float, Y>;
 
using SPLerp = Lerp<float, float, float>;

template<typename X, typename Y>
constexpr static SPLerpXY<X, Y> mapRangeSPXY(X iFromLow, X iFromHigh, Y iToLow, Y iToHigh) noexcept
{
  return SPLerpXY<X, Y>(iFromLow, iToLow, iFromHigh, iToHigh);
}
 
template<typename Y>
constexpr auto mapRangeSPY = mapRangeSPXY<float, Y>;
 
template<typename X>
constexpr auto mapRangeSPX = mapRangeSPXY<X, float>;
 
constexpr auto mapRangeSP = mapRangeSPXY<float, float>;

template<typename X, typename Y>
constexpr static Y mapValueSPXY(X iValue, X iFromLow, X iFromHigh, Y iToLow, Y iToHigh, bool iClamp = true)
{
  return SPLerpXY<X, Y>::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}

template<typename Y>
constexpr static Y mapValueSPY(float iValue, float iFromLow, float iFromHigh, Y iToLow, Y iToHigh, bool iClamp = true)
{
  return SPLerpY<Y>::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}

template<typename X>
constexpr static float mapValueSPX(X iValue, X iFromLow, X iFromHigh, float iToLow, float iToHigh, bool iClamp = true)
{
  return SPLerpX<X>::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}

constexpr static float mapValueSP(float iValue, float iFromLow, float iFromHigh, float iToLow, float iToHigh, bool iClamp = true)
{
  return SPLerp::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}
 
 
//------------------------------------------------------------------------
// DPLerp - Double Precision Lerp (double)
//------------------------------------------------------------------------
template<typename X, typename Y>
using DPLerpXY = Lerp<double, X, Y>;
 
template<typename X>
using DPLerpX = Lerp<double, X, double>;
 
template<typename Y>
using DPLerpY = Lerp<double, double, Y>;
 
using DPLerp = Lerp<double, double, double>;

template<typename X, typename Y>
static constexpr DPLerpXY<X, Y> mapRangeDPXY(X iFromLow, X iFromHigh, Y iToLow, Y iToHigh)
{
  return DPLerpXY<X, Y>(iFromLow, iToLow, iFromHigh, iToHigh);
}
 
template<typename Y>
constexpr auto mapRangeDPY = mapRangeDPXY<double, Y>;
 
template<typename X>
constexpr auto mapRangeDPX = mapRangeDPXY<X, double>;
 
constexpr auto mapRangeDP = mapRangeDPXY<double, double>;

template<typename X, typename Y>
constexpr static Y mapValueDPXY(X iValue, X iFromLow, X iFromHigh, Y iToLow, Y iToHigh, bool iClamp = true)
{
  return DPLerpXY<X, Y>::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}

template<typename Y>
constexpr static Y mapValueDPY(double iValue, double iFromLow, double iFromHigh, Y iToLow, Y iToHigh, bool iClamp = true)
{
  return DPLerpY<Y>::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}

template<typename X>
constexpr static double mapValueDPX(X iValue, X iFromLow, X iFromHigh, double iToLow, double iToHigh, bool iClamp = true)
{
  return DPLerpX<X>::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}

constexpr static double mapValueDP(double iValue, double iFromLow, double iFromHigh, double iToLow, double iToHigh, bool iClamp = true)
{
  return DPLerp::mapValue(iValue, iFromLow, iFromHigh, iToLow, iToHigh, iClamp);
}

template<typename T>
struct Range
{
  using value_type = T;
 
  // Empty constructor (no range)
  constexpr Range() = default;
 
  // Single value range
  constexpr explicit Range(T iValue) noexcept : fFrom{iValue}, fTo{iValue} {}
 
  // Constructor
  constexpr Range(T iFrom, T iTo) noexcept : fFrom{iFrom}, fTo{iTo} {}
 
  // return true if the range is a single value (aka degenerate range)
  constexpr bool isSingleValue() const { return fFrom == fTo; }

  constexpr bool contains(T iValue) const
  {
    if(fFrom < fTo)
      return iValue >= fFrom && iValue <= fTo;
    else
      return iValue <= fFrom && iValue >= fTo;
  }

  constexpr T clamp(T iValue) const
  {
    return Utils::clampRange(iValue, fFrom, fTo);
  }

  template<typename U, HasStaticMapValue<T, U> TLerp = DPLerpXY<T, U>>
  constexpr U mapValue(T iValue, Range<U> const &iRange, bool iClampToRange = true) const
  {
    return TLerp::mapValue(iValue, fFrom, fTo, iRange.fFrom, iRange.fTo, iClampToRange);
  }

  template<typename U, HasStaticMapValue<T, U> TLerp = DPLerpXY<T, U>>
  constexpr Range<U> mapRange(Range<U> const &iRange) const
  {
    // obviously *this* range is already clamped...
    return mapSubRange<U,TLerp>(*this, iRange, true);
  }

  template<typename U, HasStaticMapValue<T, U> TLerp = DPLerpXY<T, U>>
  constexpr Range<U> mapSubRange(Range<T> const &iSubRange, Range<U> const &iRange, bool iClampToRange = true) const
  {
    return Range<U>{mapValue<U,TLerp>(iSubRange.fFrom, iRange, iClampToRange),
                    mapValue<U,TLerp>(iSubRange.fTo, iRange, iClampToRange)};
  }

  template<typename U>
  constexpr Range<U> cast() const
  {
    return Range<U>{static_cast<U>(fFrom), static_cast<U>(fTo)};
  }
 
  // operator==
  bool operator==(const Range &rhs) const
  {
    return fFrom == rhs.fFrom && fTo == rhs.fTo;
  }
 
  // operator!=
  bool operator!=(const Range &rhs) const
  {
    return !(rhs == *this);
  }
 
public:
  T fFrom{};
  T fTo{};
};
 
}