ParamConverters.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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
 */
#ifndef __PONGASOFT_VST_PARAM_CONVERTERS_H__
#define __PONGASOFT_VST_PARAM_CONVERTERS_H__

#include <pongasoft/Utils/Misc.h>

#include <pluginterfaces/vst/vsttypes.h>
#include <pluginterfaces/vst/ivstparameterchanges.h>
#include <pluginterfaces/base/ustring.h>
#include <base/source/fstring.h>
#include <pluginterfaces/base/ftypes.h>

#include <cmath>
#include <algorithm>
#include <memory>
#include <string>
#include <array>
#include <vector>

namespace pongasoft {
namespace VST {

using namespace Steinberg;
using namespace Steinberg::Vst;

template<typename T>
class IParamConverter
{
public:
  using ParamType = T;
  virtual int 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;
    toString(iValue, s, iPrecision);
    return String(s).text8();
  }
};

class RawParamConverter : public IParamConverter<ParamValue>
{
public:

  using IParamConverter<ParamValue>::toString;

  inline ParamValue normalize(ParamValue const &iValue) const override
  {
    return Utils::clamp(iValue, 0.0, 1.0);
  }

  inline ParamValue denormalize(ParamValue iNormalizedValue) const override
  {
    return Utils::clamp(iNormalizedValue, 0.0, 1.0);;
  }

  inline void toString(ParamValue const &iValue, String128 oString, int32 iPrecision) const override
  {
    staticToString(iValue, oString, iPrecision);
  }

  static inline 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<bool>::toString;

  explicit BooleanParamConverter(char16 const *iFalseString = STR16("Off"),
                                 char16 const *iTrueString = STR16("On")) :
    fFalseString{iFalseString},
    fTrueString{iTrueString}
  {}

  inline int getStepCount() const override { return 1; }

  inline ParamValue normalize(bool const &iValue) const override
  {
    return iValue ? 1.0 : 0;
  }

  inline bool denormalize(ParamValue iNormalizedValue) const override
  {
    return iNormalizedValue >= 0.5;
  }

  inline void toString(bool const &iValue, String128 oString, int32 /* iPrecision */) const override
  {
    Steinberg::UString wrapper(oString, str16BufferSize(String128));
    if(iValue)
      wrapper.assign(fTrueString);
    else
      wrapper.assign(fFalseString);
  }

protected:
  char16 const *fFalseString;
  char16 const *fTrueString;
};

using Percent = double;

class PercentParamConverter : public IParamConverter<Percent>
{
public:

  using IParamConverter<Percent>::toString;

  inline ParamValue normalize(double const &iValue) const override
  {
    return Utils::clamp(iValue, 0.0, 1.0);
  }

  inline double denormalize(ParamValue iNormalizedValue) const override
  {
    return Utils::clamp(iNormalizedValue, 0.0, 1.0);
  }

  inline 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("%"));
  }
};

template<int StepCount>
class DiscreteValueParamConverter : public IParamConverter<int>
{
public:
  using ParamType = int;

  using IParamConverter<int>::toString;

  // Constructor - you can provide an offset for the toString conversion (ex: counting from 1 instead of 0)
  explicit DiscreteValueParamConverter(int iToStringOffset = 0) : fToStringOffset{iToStringOffset} {}

  // Constructor with printf style format where the parameter (%d) will be (value + offset)
  explicit DiscreteValueParamConverter(char16 const *iFormat, int iToStringOffset = 0) :
    fToStringOffset{iToStringOffset}, fFormat{iFormat} {}

  // Constructor with all values defined
  explicit DiscreteValueParamConverter(std::array<ConstString, StepCount + 1> const &iToStringValues) :
    fToStringValues(iToStringValues.cbegin(), iToStringValues.cend()) {}

  inline int getStepCount() const override { return StepCount; }

  inline ParamValue normalize(int const &iDiscreteValue) const override
  {
    auto value = Utils::clamp(iDiscreteValue, 0, StepCount);
    return value / static_cast<double>(StepCount);
  }

  inline int denormalize(ParamValue iNormalizedValue) const override
  {
    // ParamValue must remain within its bounds
    auto value = Utils::clamp(iNormalizedValue, 0.0, 1.0);
    return static_cast<int>(std::floor(std::min(static_cast<ParamValue>(StepCount),
                                                value * (StepCount + 1))));
  }

  // toString
  void toString(ParamType const &iValue, String128 oString, int32 /* iPrecision */) const override
  {
    Steinberg::UString wrapper(oString, str16BufferSize (String128));
    if(fFormat)
    {
      String s;
      s.printf(fFormat, iValue + fToStringOffset);
      wrapper.assign(s.text());
    }
    else
    {
      if(fToStringValues.empty())
      {
        if(!wrapper.printInt(iValue + fToStringOffset))
          oString[0] = 0;
      }
      else
      {
        wrapper.assign(fToStringValues[iValue].text());
      }
    }
  }

private:
  int fToStringOffset{};
  char16 const *fFormat{};
  std::vector<ConstString> fToStringValues{};
};

template<typename Enum, Enum MaxValue>
class EnumParamConverter : public IParamConverter<Enum>
{
public:
  using ParamType = Enum;

  using IParamConverter<Enum>::toString;

  // Constructor - you can provide an offset for the toString conversion (ex: counting from 1 instead of 0)
  explicit EnumParamConverter(int iToStringOffset = 0) : fConverter{iToStringOffset} {}

  // Constructor with printf style format where the parameter (%d) will be (value + offset)
  explicit EnumParamConverter(char16 const *iFormat, int iToStringOffset = 0) : fConverter{iFormat, iToStringOffset} {}

  // Constructor with all values defined
  explicit EnumParamConverter(std::array<ConstString, MaxValue + 1> const &iToStringValues) : fConverter{iToStringValues} {}

  inline int getStepCount() const override { return fConverter.getStepCount(); }

  inline ParamValue normalize(ParamType const &iDiscreteValue) const override
  {
    return fConverter.normalize(iDiscreteValue);
  }

  inline ParamType denormalize(ParamValue iNormalizedValue) const override
  {
    return static_cast<ParamType>(fConverter.denormalize(iNormalizedValue));
  }

  void toString(ParamType const &iValue, String128 oString, int32 iPrecision) const override
  {
    fConverter.toString(iValue, oString, iPrecision);
  }

private:
  DiscreteValueParamConverter<MaxValue> fConverter;
};

}
}

#endif // __PONGASOFT_VST_PARAM_CONVERTERS_H__