ParamConverters.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2020 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 <pongasoft/Utils/Misc.h>
#include <pongasoft/Utils/Concepts.h>
#include <pongasoft/VST/Types.h>
#include <pongasoft/VST/VstUtils/Utils.h>
 
#include <pluginterfaces/vst/vsttypes.h>
#include <pluginterfaces/base/ustring.h>
#include <base/source/fstring.h>
#include <pluginterfaces/base/ftypes.h>
 
#include <algorithm>
#include <concepts>
#include <string>
#include <array>
#include <vector>
#include <map>
#include <type_traits>
#include <pongasoft/Utils/Constants.h>
 
namespace pongasoft::VST {
 
using namespace Steinberg;
using namespace Steinberg::Vst;

template<typename T>
class IParamConverter
{
public:
  virtual ~IParamConverter() = default;
 
  using ParamType = T;
  virtual int32 getStepCount() const { return 0; }
  virtual ParamValue normalize(ParamType const &iValue) const = 0;
  virtual ParamType denormalize(ParamValue iNormalizedValue) const = 0;
  virtual void toString(ParamType const &iValue, String128 iString, int32 iPrecision) const { }
  virtual std::string toString(ParamType const &iValue, int32 iPrecision) const
  {
    String128 s;
    s[0] = 0;
    toString(iValue, s, iPrecision);
    return VstUtils::toUT8String(s);
  }
};
 
template<typename T, typename ParamType>
concept IsDerivedFromIParamConverter = std::derived_from<T, IParamConverter<ParamType>>;

template<typename T>
concept IsIParamConverter = requires
                            { typename T::ParamType; } &&
                            IsDerivedFromIParamConverter<T, typename T::ParamType>;

class RawParamConverter : public IParamConverter<ParamValue>
{
public:
 
  using IParamConverter::toString;
 
  ParamValue normalize(ParamValue const &iValue) const override
  {
    return Utils::clamp(iValue, 0.0, 1.0);
  }
 
  ParamValue denormalize(ParamValue iNormalizedValue) const override
  {
    return Utils::clamp(iNormalizedValue, 0.0, 1.0);
  }
 
  void toString(ParamValue const &iValue, String128 oString, int32 iPrecision) const override
  {
    staticToString(iValue, oString, iPrecision);
  }
 
  static void staticToString(ParamValue const &iValue, String128 oString, int32 iPrecision)
  {
    Steinberg::UString wrapper(oString, str16BufferSize(String128));
    if(!wrapper.printFloat(iValue, iPrecision))
      oString[0] = 0;
  }
};

class BooleanParamConverter : public IParamConverter<bool>
{
public:
  using IParamConverter::toString;
 
  explicit BooleanParamConverter(VstString16 iFalseString = STR16("Off"),
                                 VstString16 iTrueString = STR16("On")) :
    fFalseString{std::move(iFalseString)},
    fTrueString{std::move(iTrueString)}
  {}
 
  int32 getStepCount() const override { return 1; }
 
  ParamValue normalize(bool const &iValue) const override
  {
    return iValue ? 1.0 : 0;
  }
 
  bool denormalize(ParamValue iNormalizedValue) const override
  {
    return toBoolean(iNormalizedValue);
  }
 
  void toString(bool const &iValue, String128 oString, int32 /* iPrecision */) const override
  {
    Steinberg::UString wrapper(oString, str16BufferSize(String128));
    if(iValue)
      wrapper.assign(fTrueString.c_str());
    else
      wrapper.assign(fFalseString.c_str());
  }

  static constexpr bool toBoolean(ParamValue iNormalizedValue) { return iNormalizedValue >= 0.5; }
 
protected:
  VstString16 fFalseString;
  VstString16 fTrueString;
};

using Percent = double;

class PercentParamConverter : public IParamConverter<Percent>
{
public:
 
  using IParamConverter::toString;
 
  ParamValue normalize(Percent const &iValue) const override
  {
    return Utils::clamp(iValue, 0.0, 1.0);
  }
 
  Percent denormalize(ParamValue iNormalizedValue) const override
  {
    return Utils::clamp(iNormalizedValue, 0.0, 1.0);
  }
 
  void toString(ParamType const &iValue, String128 oString, int32 iPrecision) const override
  {
    Steinberg::UString wrapper(oString, str16BufferSize (String128));
    wrapper.printFloat(iValue * 100, iPrecision);
    wrapper.append(STR16("%"));
  }
};

static constexpr ParamValue convertDiscreteValueToNormalizedValue(int32 iStepCount, int32 iDiscreteValue)
{
  auto value = Utils::clamp<int32, int32>(iDiscreteValue, 0, iStepCount);
  if(value == 0)
    return value;
  else
    return value / static_cast<ParamValue>(iStepCount);
}

static constexpr int32 convertNormalizedValueToDiscreteValue(int32 iStepCount, ParamValue iNormalizedValue)
{
  // ParamValue must remain within its bounds
  auto value = Utils::clamp(iNormalizedValue, 0.0, 1.0);
  auto discreteValue = std::min(static_cast<ParamValue>(iStepCount), value * (iStepCount + 1));
  // Implementation note: this takes care of std::floor and is 100% equivalent since we know everything is >= 0
  return static_cast<int32>(discreteValue);
}

static constexpr int32 computeNextDiscreteValue(int32 iValue, int32 iStepCount, int32 iIncrement, bool iWrap)
{
  // no increment, noop
  if(iIncrement == 0)
    return iValue;
 
  if(iStepCount > 0)
  {
    auto discreteValue = iValue + iIncrement;
 
    // handles wrapping
    if(iWrap)
    {
      if(iIncrement > 0)
      {
        while(discreteValue > iStepCount)
          discreteValue -= iStepCount + 1;
      }
      else
      {
        while(discreteValue < 0)
          discreteValue += iStepCount + 1;
      }
    }
    else
    {
      // no wrapping => simply clamp the value to the range
      discreteValue = Utils::clamp(discreteValue, Utils::ZERO_INT32, iStepCount);
    }
 
    return discreteValue;
  }
  else
  {
    return iValue;
  }
}

template<int32 StepCount, Utils::IntegralOrEnum IntType = int32>
class DiscreteValueParamConverter : public IParamConverter<IntType>
{
public:
  using ParamType = IntType;
 
  using IParamConverter<IntType>::toString;

  using ConstructorType = std::array<VstString16, StepCount + 1> const &;
 
  // Constructor - you can provide an offset for the toString conversion (ex: counting from 1 instead of 0)
  explicit DiscreteValueParamConverter(IntType iToStringOffset = 0) : fToStringOffset{iToStringOffset} {}
 
  // Constructor with printf style format where the parameter (%d) will be (value + offset)
  explicit DiscreteValueParamConverter(VstString16 iFormat, IntType iToStringOffset = 0) :
    fToStringOffset{iToStringOffset}, fFormat{std::move(iFormat)} {}
 
  // Constructor with all values defined
  explicit DiscreteValueParamConverter(ConstructorType iToStringValues) :
    fToStringValues(iToStringValues.cbegin(), iToStringValues.cend()) {}
 
  int32 getStepCount() const override { return StepCount; }
 
  ParamValue normalize(ParamType const &iDiscreteValue) const override
  {
    return convertDiscreteValueToNormalizedValue(StepCount, static_cast<int32>(iDiscreteValue));
  }
 
  ParamType denormalize(ParamValue iNormalizedValue) const override
  {
    return static_cast<ParamType>(convertNormalizedValueToDiscreteValue(StepCount, iNormalizedValue));
  }
 
  // toString
  void toString(ParamType const &iValue, String128 oString, int32 /* iPrecision */) const override
  {
    Steinberg::UString wrapper(oString, str16BufferSize (String128));
    if(!fFormat.empty())
    {
      Steinberg::String s;
      s.printf(fFormat.c_str(), iValue + fToStringOffset);
      wrapper.assign(s.text());
    }
    else
    {
      if(fToStringValues.empty())
      {
        if(!wrapper.printInt(iValue + fToStringOffset))
          oString[0] = 0;
      }
      else
      {
        wrapper.assign(fToStringValues[iValue].c_str());
      }
    }
  }
 
private:
  IntType fToStringOffset{};
  VstString16 fFormat{};
  std::vector<VstString16> fToStringValues{};
};

template<typename T, class Compare = std::less<T>>
class DiscreteTypeParamConverter : public IParamConverter<T>
{
public:
  using TMap = std::map<T, std::tuple<VstString16, ParamValue, int32>, Compare>;

  using TList = std::vector<T>;

  using ConstructorType = std::initializer_list<std::pair<const T, VstString16>> const &;
 
  using ParamType = T;
 
  using IParamConverter<T>::toString;

  DiscreteTypeParamConverter(ConstructorType iInitList)
  {
    auto stepCount = static_cast<int32>(iInitList.size() - 1);
 
    // by definition, a discrete parameter has a step count > 0
    DCHECK_F(stepCount > 0);
 
    int32 i = 0;
    for(auto &pair : iInitList)
    {
      auto paramValue = convertDiscreteValueToNormalizedValue(stepCount, i);
      fMap[pair.first] = std::make_tuple(pair.second, paramValue, i);
      fList.emplace_back(pair.first);
      i++;
    }
 
    // sanity check... if not the same size it means that 2 entries in the list were the same!
    DCHECK_F(fList.size() == fMap.size());
  }
 
  // getStepCount
  int32 getStepCount() const override { return static_cast<int32>(fMap.size() - 1); }
 
  // normalize
  ParamValue normalize(ParamType const &iValue) const override
  {
    auto iter = fMap.find(iValue);
    if(iter != fMap.cend())
      return std::get<1>(iter->second);
    else
    {
      DLOG_F(WARNING, "could not normalize value...");
      return 0;
    }
  }
 
  // denormalize
  ParamType denormalize(ParamValue iNormalizedValue) const override
  {
    auto index = convertNormalizedValueToDiscreteValue(getStepCount(), iNormalizedValue);
    return fList[index];
  }
 
  // toString
  void toString(ParamType const &iValue, String128 oString, int32 iPrecision) const override
  {
    auto iter = fMap.find(iValue);
    if(iter != fMap.cend())
    {
      Steinberg::UString wrapper(oString, str16BufferSize (String128));
      wrapper.assign(std::get<0>(iter->second).c_str());
    }
    else
      oString[0] = 0;
  }
 
private:
  TMap fMap{};
  TList fList{};
};

template<typename Enum, Enum MaxValue> requires std::is_enum_v<Enum>
class EnumParamConverter : public IParamConverter<Enum>
{
public:
  using ParamType = Enum;
 
  using IntType = std::underlying_type_t<Enum>;
 
  using IParamConverter<Enum>::toString;

  using ConstructorType = std::array<VstString16, MaxValue + 1> const &;
 
  // Constructor - you can provide an offset for the toString conversion (ex: counting from 1 instead of 0)
  explicit EnumParamConverter(IntType iToStringOffset = 0) : fConverter{iToStringOffset} {}
 
  // Constructor with printf style format where the parameter (%d) will be (value + offset)
  explicit EnumParamConverter(VstString16 iFormat, IntType iToStringOffset = 0) : fConverter{std::move(iFormat), iToStringOffset} {}
 
  // Constructor with all values defined
  explicit EnumParamConverter(ConstructorType iToStringValues) : fConverter{iToStringValues} {}
 
  // getStepCount
  int32 getStepCount() const override { return MaxValue; }
 
  // normalize
  ParamValue normalize(ParamType const &iDiscreteValue) const override
  {
    return fConverter.normalize(static_cast<IntType>(iDiscreteValue));
  }
 
  // denormalize
  ParamType denormalize(ParamValue iNormalizedValue) const override
  {
    return static_cast<Enum>(fConverter.denormalize(iNormalizedValue));
  }
 
  // toString
  void toString(ParamType const &iValue, String128 oString, int32 iPrecision) const override
  {
    fConverter.toString(static_cast<IntType>(iValue), oString, iPrecision);
  }
 
private:
  DiscreteValueParamConverter<MaxValue, IntType> fConverter;
};
 
 
}