PluginFactory.h

Go to the documentation of this file.

/*
 * Copyright (c) 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 <string>
#include <functional>
#include <vector>
 
#include <pluginterfaces/base/funknown.h>
#include <pluginterfaces/base/ipluginbase.h>
#include <pluginterfaces/vst/ivstaudioprocessor.h>
#include <pluginterfaces/vst/ivstcomponent.h>
#include <public.sdk/source/main/pluginfactory.h>
 
// SDK 3.7.1 renamed the old define so restoring it to avoid backward incompatibilities
#define EXPORT_FACTORY SMTG_EXPORT_SYMBOL
 
namespace pongasoft::VST {

class JambaPluginFactory
{
public:
  template<typename RTProcessorClass, typename GUIControllerClass>
  static Steinberg::IPluginFactory* GetVST3PluginFactory(const std::string& iVendor,
                                                         const std::string& iURL,
                                                         const std::string& iEmail,
                                                         const std::string& iPluginName,
                                                         const std::string& iPluginVersion,
                                                         const std::string& iSubCategories,
                                                         void *iContext = nullptr)
  {
    return createFactory<RTProcessorClass, GUIControllerClass>(iVendor,
                                                               iURL,
                                                               iEmail,
                                                               iPluginName,
                                                               iPluginVersion,
                                                               iSubCategories,
                                                               iContext,
                                                               static_cast<Steinberg::int32>(Steinberg::Vst::kDistributable));
  }

  template<typename RTProcessorClass, typename GUIControllerClass>
  static Steinberg::IPluginFactory* GetNonDistributableVST3PluginFactory(const std::string& iVendor,
                                                                         const std::string& iURL,
                                                                         const std::string& iEmail,
                                                                         const std::string& iPluginName,
                                                                         const std::string& iPluginVersion,
                                                                         const std::string& iSubCategories,
                                                                         void *iContext = nullptr)
  {
    return createFactory<RTProcessorClass, GUIControllerClass>(iVendor,
                                                               iURL,
                                                               iEmail,
                                                               iPluginName,
                                                               iPluginVersion,
                                                               iSubCategories,
                                                               iContext,
                                                               0); // non distributable
  }
 
 
private:
  // createFactory
  template<typename RTProcessorClass, typename GUIControllerClass>
  static Steinberg::IPluginFactory* createFactory(const std::string& iVendor,
                                                  const std::string& iURL,
                                                  const std::string& iEmail,
                                                  const std::string& iPluginName,
                                                  const std::string& iPluginVersion,
                                                  const std::string& iSubCategories,
                                                  void *iContext,
                                                  int32 iProcessorFlags);
};
 
//------------------------------------------------------------------------
// JambaPluginFactory::GetVST3PluginFactory
//------------------------------------------------------------------------
template<typename RTClass, typename GUIClass>
Steinberg::IPluginFactory *JambaPluginFactory::createFactory(std::string const &iVendor,
                                                             std::string const &iURL,
                                                             std::string const &iEmail,
                                                             std::string const &iPluginName,
                                                             std::string const &iPluginVersion,
                                                             std::string const &iSubCategories,
                                                             void *iContext,
                                                             int32 iProcessorFlags)
{
  // implementation note: this code was essentially copied from the macros coming from the SDKs and adapted this way:
  // 1) do not use Steinberg::gPluginFactory global variable
  // 2) do not use any static variables (which end up being small memory leaks)
  Steinberg::PFactoryInfo factoryInfo(iVendor.c_str(),
                                      iURL.c_str(),
                                      iEmail.c_str(),
                                      Steinberg::Vst::kDefaultFactoryFlags);
 
  // wrapping in a unique_ptr to make sure it gets destroyed if the method does not end properly
  auto factory = std::make_unique<Steinberg::CPluginFactory>(factoryInfo);
 
  // processor
  {
    Steinberg::TUID lcid = INLINE_UID_FROM_FUID(RTClass::UUID());
    Steinberg::PClassInfo2 component{lcid,
                                     Steinberg::PClassInfo::kManyInstances,
                                     kVstAudioEffectClass,
                                     iPluginName.c_str(),
                                     iProcessorFlags,
                                     iSubCategories.c_str(),
                                     nullptr,
                                     iPluginVersion.c_str(),
                                     kVstVersionString};
 
    factory->registerClass(&component, RTClass::createInstance, iContext);
  }
 
  // controller
  {
    Steinberg::TUID lcid = INLINE_UID_FROM_FUID(GUIClass::UUID());
    Steinberg::PClassInfo2 component{lcid,
                                     Steinberg::PClassInfo::kManyInstances,
                                     kVstComponentControllerClass,
                                     (iPluginName + "Controller").c_str(),
                                     0,
                                     nullptr,
                                     nullptr,
                                     iPluginVersion.c_str(),
                                     kVstVersionString};
 
    factory->registerClass(&component, GUIClass::createInstance, iContext);
  }
 
  // here we can release the pointer as it becomes the responsibility of the caller to manage its
  // lifecycle
  return factory.release();
}
 
 
}