Initial release

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/CMakeLists.txt

@@ -0,0 +1,51 @@
+
+if(NOT SMTG_LINUX)
+    set(target aax_wrapper)
+    set(${target}_sources
+        ${SDK_ROOT}/public.sdk/source/vst/basewrapper/basewrapper.sdk.cpp
+        aaxentry.cpp
+        aaxlibrary.cpp
+        aaxwrapper.cpp
+        aaxwrapper.h
+        aaxwrapper_description.h
+        aaxwrapper_gui.cpp
+        aaxwrapper_gui.h
+        aaxwrapper_parameters.cpp
+        aaxwrapper_parameters.h
+        resource/PlugIn.ico
+    )
+    add_library(${target} STATIC ${${target}_sources})
+
+    target_include_directories(${target}
+        PRIVATE
+            "${SMTG_AAX_SDK_PATH}/Interfaces"
+            "${SMTG_AAX_SDK_PATH}/Interfaces/ACF"
+            "${SMTG_AAX_SDK_PATH}/Libs/AAXLibrary/Include"
+    )
+    target_link_libraries(${target}
+        PRIVATE
+            base
+    )
+    smtg_target_setup_universal_binary(${target})
+
+    target_compile_features(aax_wrapper
+        PUBLIC
+            cxx_std_17
+    )
+
+    if(XCODE)
+        add_compile_options(-Wno-incompatible-ms-struct)
+    elseif(SMTG_WIN)
+        # too much warnings in the AAX SDK!!
+        add_compile_options(/wd4996)
+        add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+        add_compile_options(/GR)
+        if(MSVC)
+            target_compile_options(${target} 
+                PRIVATE 
+                    /wd4127 # conditional expression is constant
+                    /wd5033 # 'register' is no longer a supported storage class
+            )
+        endif(MSVC)
+    endif(XCODE)
+endif()

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxentry.cpp

@@ -0,0 +1,213 @@
+//------------------------------------------------------------------------
+// Flags       : clang-format SMTGSequencer
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxentry.h
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses.
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+/**
+ *	plugin entry from AAX_Exports.cpp
+ */
+//-----------------------------------------------------------------------------
+
+#include "pluginterfaces/base/fplatform.h"
+
+// change names to avoid different linkage
+#define ACFRegisterPlugin ACFRegisterPlugin_
+#define ACFRegisterComponent ACFRegisterComponent_
+#define ACFGetClassFactory ACFGetClassFactory_
+
+#define ACFCanUnloadNow ACFCanUnloadNow_
+#define ACFStartup ACFStartup_
+#define ACFShutdown ACFShutdown_
+
+//#define INITACFIDS // Make sure all of the AVX2 uids are defined.
+
+#include "AAX.h"
+#include "AAX_Init.h"
+#include "acfresult.h"
+#include "acfunknown.h"
+
+#undef ACFRegisterPlugin
+#undef ACFRegisterComponent
+#undef ACFGetClassFactory
+
+#undef ACFCanUnloadNow
+#undef ACFStartup
+#undef ACFShutdown
+
+// defined in basewrapper.cpp
+extern bool _InitModule ();
+extern bool _DeinitModule ();
+
+// reference this in the plugin to force inclusion of the wrapper in the link
+int AAXWrapper_linkAnchor;
+
+//------------------------------------------------------------------------
+#if defined(__GNUC__)
+#define AAX_EXPORT extern "C" __attribute__ ((visibility ("default"))) ACFRESULT
+#else
+#define AAX_EXPORT extern "C" __declspec (dllexport) ACFRESULT __stdcall
+#endif
+
+AAX_EXPORT ACFRegisterPlugin (IACFUnknown* pUnkHost, IACFPluginDefinition** ppPluginDefinition);
+AAX_EXPORT ACFRegisterComponent (IACFUnknown* pUnkHost, acfUInt32 index,
+                                 IACFComponentDefinition** ppComponentDefinition);
+AAX_EXPORT ACFGetClassFactory (IACFUnknown* pUnkHost, const acfCLSID& clsid, const acfIID& iid,
+                               void** ppOut);
+
+AAX_EXPORT ACFCanUnloadNow (IACFUnknown* pUnkHost);
+AAX_EXPORT ACFStartup (IACFUnknown* pUnkHost);
+AAX_EXPORT ACFShutdown (IACFUnknown* pUnkHost);
+AAX_EXPORT ACFGetSDKVersion (acfUInt64* oSDKVersion);
+
+//------------------------------------------------------------------------
+// \func ACFRegisterPlugin
+// \brief Determines the number of components defined in the dll.
+//
+ACFAPI ACFRegisterPlugin (IACFUnknown* pUnkHostVoid, IACFPluginDefinition** ppPluginDefinitionVoid)
+{
+	ACFRESULT result = ACF_OK;
+
+	try
+	{
+		result = AAXRegisterPlugin (pUnkHostVoid, ppPluginDefinitionVoid);
+	}
+	catch (...)
+	{
+		result = ACF_E_UNEXPECTED;
+	}
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+// \func ACFRegisterComponent
+// \brief Registers a specific component in the DLL.
+//
+ACFAPI ACFRegisterComponent (IACFUnknown* pUnkHost, acfUInt32 index,
+                             IACFComponentDefinition** ppComponentDefinition)
+{
+	ACFRESULT result = ACF_OK;
+
+	try
+	{
+		result = AAXRegisterComponent (pUnkHost, index, ppComponentDefinition);
+	}
+	catch (...)
+	{
+		result = ACF_E_UNEXPECTED;
+	}
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+// \func ACFGetClassFactory
+// \brief Gets the factory for a given class ID.
+//
+ACFAPI ACFGetClassFactory (IACFUnknown* pUnkHost, const acfCLSID& clsid, const acfIID& iid,
+                           void** ppOut)
+{
+	ACFRESULT result = ACF_OK;
+
+	try
+	{
+		result = AAXGetClassFactory (pUnkHost, clsid, iid, ppOut);
+	}
+	catch (...)
+	{
+		result = ACF_E_UNEXPECTED;
+	}
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+// \func ACFCanUnloadNow
+// \brief Figures out if all objects are released so we can unload.
+//
+ACFAPI ACFCanUnloadNow (IACFUnknown* pUnkHost)
+{
+	ACFRESULT result = ACF_OK;
+
+	try
+	{
+		result = AAXCanUnloadNow (pUnkHost);
+	}
+	catch (...)
+	{
+		result = ACF_E_UNEXPECTED;
+	}
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+// \func ACFStartup
+// \brief Called once at init time.
+//
+ACFAPI ACFStartup (IACFUnknown* pUnkHost)
+{
+	ACFRESULT result = ACF_OK;
+
+	try
+	{
+		result = AAXStartup (pUnkHost);
+		if (result == ACF_OK)
+		{
+			if (!_InitModule ())
+			{
+				AAXShutdown (pUnkHost);
+				result = ACF_E_UNEXPECTED;
+			}
+		}
+	}
+	catch (...)
+	{
+		result = ACF_E_UNEXPECTED;
+	}
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+// \func ACFShutdown
+// \brief Called once at termination of dll.
+//
+ACFAPI ACFShutdown (IACFUnknown* pUnkHost)
+{
+	ACFRESULT result = ACF_OK;
+
+	try
+	{
+		_DeinitModule ();
+		result = AAXShutdown (pUnkHost);
+	}
+	catch (...)
+	{
+		result = ACF_E_UNEXPECTED;
+	}
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+ACFAPI ACFGetSDKVersion (acfUInt64* oSDKVersion)
+{
+	return AAXGetSDKVersion (oSDKVersion);
+}
+
+/// \endcond

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxlibrary.cpp

@@ -0,0 +1,95 @@
+//------------------------------------------------------------------------
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxlibrary.cpp
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses. 
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+// instead of linking to a library, we just include the sources here to have
+// full control over compile settings
+
+#define I18N_LIB 1
+#define PLUGIN_SDK_BUILD 1
+#define DPA_PLUGIN_BUILD 1
+#define INITACFIDS // Make sure all of the AVX2 uids are defined.
+#define UNICODE 1
+
+#ifdef _WIN32
+#ifndef WIN32
+#define WIN32 // for CMutex.cpp
+#endif
+#define WINDOWS_VERSION 1 // for AAXWrapper_GUI.h
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreorder"
+#pragma clang diagnostic ignored "-Wundef-prefix"
+#endif
+
+#include "AAX_Atomic.h"
+
+#include "../Interfaces/ACF/CACFClassFactory.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CACFUnknown.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CChunkDataParser.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CEffectDirectData.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CEffectGUI.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CEffectParameters.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CHostProcessor.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CHostServices.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CMutex.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CPacketDispatcher.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CParameter.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CParameterManager.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CString.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CUIDs.cpp"
+#include "../Libs/AAXLibrary/source/AAX_CommonConversions.cpp"
+#include "../Libs/AAXLibrary/source/AAX_IEffectDirectData.cpp"
+#include "../Libs/AAXLibrary/source/AAX_IEffectGUI.cpp"
+#include "../Libs/AAXLibrary/source/AAX_IEffectParameters.cpp"
+#include "../Libs/AAXLibrary/source/AAX_IHostProcessor.cpp"
+#include "../Libs/AAXLibrary/source/AAX_Init.cpp"
+#include "../Libs/AAXLibrary/source/AAX_Properties.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VAutomationDelegate.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VCollection.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VComponentDescriptor.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VController.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VDescriptionHost.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VEffectDescriptor.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VFeatureInfo.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VHostProcessorDelegate.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VHostServices.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VPageTable.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VPrivateDataAccess.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VPropertyMap.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VTransport.cpp"
+#include "../Libs/AAXLibrary/source/AAX_VViewContainer.cpp"
+
+#ifdef _WIN32
+#include "../Libs/AAXLibrary/source/AAX_CAutoreleasePool.Win.cpp"
+#else
+//#include "../Libs/AAXLibrary/source/AAX_CAutoreleasePool.OSX.mm"
+#endif
+
+#undef min
+#undef max
+
+// put at the very end, uses "using namespace std"
+#include "../Libs/AAXLibrary/source/AAX_SliderConversions.cpp"
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+/// \endcond

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxwrapper.h

@@ -0,0 +1,178 @@
+//------------------------------------------------------------------------
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxwrapper.h
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses. 
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+#pragma once
+
+#include "public.sdk/source/vst/basewrapper/basewrapper.h"
+#include "base/thread/include/flock.h"
+#include <bitset>
+#include <list>
+#include <memory>
+
+struct AAX_Plugin_Desc;
+struct AAX_Effect_Desc;
+class AAX_IComponentDescriptor;
+
+class AAXWrapper_Parameters;
+class AAXWrapper_GUI;
+
+namespace Steinberg {
+namespace Vst {
+class IAudioProcessor;
+class IEditController;
+}
+}
+
+struct AAXWrapper_Context
+{
+	void* ptr[1]; // array of numDataPointers pointers
+};
+
+//------------------------------------------------------------------------
+class AAXWrapper : public Steinberg::Vst::BaseWrapper,
+                   public Steinberg::Vst::IComponentHandler2,
+                   public Steinberg::Vst::IVst3ToAAXWrapper
+{
+public:
+	// static creation method (will owned factory)
+	static AAXWrapper* create (Steinberg::IPluginFactory* factory,
+	                           const Steinberg::TUID vst3ComponentID, AAX_Plugin_Desc* desc,
+	                           AAXWrapper_Parameters* p);
+
+	AAXWrapper (Steinberg::Vst::BaseWrapper::SVST3Config& config, AAXWrapper_Parameters* p, AAX_Plugin_Desc* desc);
+	~AAXWrapper ();
+
+	//--- VST 3 Interfaces  ------------------------------------------------------
+	// IHostApplication
+	Steinberg::tresult PLUGIN_API getName (Steinberg::Vst::String128 name) SMTG_OVERRIDE;
+
+	// IComponentHandler
+	Steinberg::tresult PLUGIN_API beginEdit (Steinberg::Vst::ParamID tag) SMTG_OVERRIDE;
+	Steinberg::tresult PLUGIN_API performEdit (
+	    Steinberg::Vst::ParamID tag, Steinberg::Vst::ParamValue valueNormalized) SMTG_OVERRIDE;
+	Steinberg::tresult PLUGIN_API endEdit (Steinberg::Vst::ParamID tag) SMTG_OVERRIDE;
+	Steinberg::tresult PLUGIN_API restartComponent (Steinberg::int32 flags) SMTG_OVERRIDE;
+
+	// IComponentHandler2
+	Steinberg::tresult PLUGIN_API setDirty (Steinberg::TBool state) SMTG_OVERRIDE;
+	Steinberg::tresult PLUGIN_API requestOpenEditor (
+	    Steinberg::FIDString name = Steinberg::Vst::ViewType::kEditor) SMTG_OVERRIDE;
+	Steinberg::tresult PLUGIN_API startGroupEdit () SMTG_OVERRIDE;
+	Steinberg::tresult PLUGIN_API finishGroupEdit () SMTG_OVERRIDE;
+
+	// FUnknown
+	DEF_INTERFACES_2 (Steinberg::Vst::IComponentHandler2, Steinberg::Vst::IVst3ToAAXWrapper, BaseWrapper);
+	REFCOUNT_METHODS (BaseWrapper);
+
+	// AAXWrapper_Parameters callbacks
+	void setGUI (AAXWrapper_GUI* gui) { mAAXGUI = gui; }
+	Steinberg::int32 /*AAX_Result*/ getParameterInfo (const char* aaxId,
+	                                                  Steinberg::Vst::ParameterInfo& paramInfo);
+	Steinberg::int32 /*AAX_Result*/ ResetFieldData (Steinberg::int32 index, void* inData,
+	                                                Steinberg::uint32 inDataSize);
+	Steinberg::int32 Process (AAXWrapper_Context* instance);
+
+	Steinberg::uint32 getNumMIDIports () const { return mCountMIDIports; }
+
+	void setSideChainEnable (bool enable);
+	bool generatePageTables (const char* outputFile);
+	void setRenderingOffline (bool val);
+
+	static void DescribeAlgorithmComponent (AAX_IComponentDescriptor* outDesc,
+	                                        const AAX_Effect_Desc* desc,
+	                                        const AAX_Plugin_Desc* pdesc);
+
+	//--- ---------------------------------------------------------------------
+	Steinberg::uint32 getNumAAXOutputs () const { return mAAXOutputs; }
+
+	//------------------------------------------------------------------------
+	// BaseWrapper overrides ---------------------------------
+	//------------------------------------------------------------------------
+	bool init () SMTG_OVERRIDE;
+	bool _sizeWindow (Steinberg::int32 width, Steinberg::int32 height) SMTG_OVERRIDE;
+	void onTimer (Steinberg::Timer* timer) SMTG_OVERRIDE;
+
+	Steinberg::int32 _getChunk (void** data, bool isPreset) SMTG_OVERRIDE;
+	Steinberg::int32 _setChunk (void* data, Steinberg::int32 byteSize, bool isPreset) SMTG_OVERRIDE;
+	void setupProcessTimeInfo () SMTG_OVERRIDE;
+
+//------------------------------------------------------------------------
+private:
+	void processOutputParametersChanges () SMTG_OVERRIDE;
+	
+	Steinberg::tresult setupBusArrangements (AAX_Plugin_Desc* desc);
+	Steinberg::int32 countSidechainBusChannels (Steinberg::Vst::BusDirection dir,
+	                                            Steinberg::uint64& scBusBitset);
+
+	void guessActiveOutputs (float** out, Steinberg::uint32 num);
+	void updateActiveOutputState ();
+
+	AAXWrapper_Parameters* mAAXParams = nullptr;
+	AAXWrapper_GUI* mAAXGUI = nullptr;
+
+	Steinberg::uint32 mAAXOutputs = 0;
+
+	Steinberg::Base::Thread::FLock mSyncCalls; // synchronize calls expected in the same thread in VST3
+	AAX_Plugin_Desc* mPluginDesc = nullptr;
+	Steinberg::uint32 mCountMIDIports = 0;
+
+	// as of ProTools 12 (?) the context struct does no longer allow unused slots,
+	//  so we have to generate indices into the context struct dynamically
+	// context pointer to AAXWrapper always first
+	static const Steinberg::int32 idxContext = 0;
+	static const Steinberg::int32 idxBufferSize = 1;
+	Steinberg::int32 idxInputChannels = -1;
+	Steinberg::int32 idxOutputChannels = -1;
+	Steinberg::int32 idxSideChainInputChannels = -1;
+	Steinberg::int32 idxMidiPorts = -1;
+	Steinberg::int32 idxAuxOutputs = -1;
+	Steinberg::int32 idxMeters = -1;
+	Steinberg::int32 numDataPointers = 0;
+
+	static const Steinberg::int32 maxActiveChannels = 128;
+	std::bitset<maxActiveChannels> mActiveChannels;
+	std::bitset<maxActiveChannels> mPropagatedChannels;
+
+	Steinberg::uint32 mCntMeters = 0;
+	std::unique_ptr<Steinberg::Vst::ParamID[]> mMeterIds;
+
+	struct GetChunkMessage;
+	void* mainThread = nullptr;
+	Steinberg::Base::Thread::FLock msgQueueLock;
+	std::list<GetChunkMessage*> msgQueue;
+
+	float mBypassGain = 1.0;
+	float* mMetersTmp = nullptr;
+
+	Steinberg::Vst::TQuarterNotes mLastPpqPos = 0;
+	Steinberg::Vst::TQuarterNotes mNextPpqPos = 0;
+
+	bool mWantsSetChunk = false;
+	bool mSettingChunk = false;
+	bool mSimulateBypass = false;
+	bool mBypass = false;
+
+	bool mPresetChanged = false;
+	bool mBypassBeforePresetChanged = false;
+	bool mWantsSetChunkIsPreset = false;
+
+	friend class AAXWrapper_Parameters;
+	friend class AAXWrapper_GUI;
+};
+
+/// \endcond

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxwrapper_description.h

@@ -0,0 +1,84 @@
+//------------------------------------------------------------------------
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxwrapper_description.h
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses. 
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+#pragma once
+
+#include "base/source/fstring.h"
+
+using namespace Steinberg;
+
+struct AAX_Aux_Desc
+{
+	const char* mName;
+	int32 mChannels; // -1 for same as output channel
+};
+
+struct AAX_Meter_Desc
+{
+	const char* mName;
+	uint32 mID;
+	uint32 mOrientation; // see AAX_EMeterOrientation
+	uint32 mType; // see AAX_EMeterType
+};
+
+struct AAX_MIDI_Desc
+{
+	const char* mName;
+	uint32 mMask;
+};
+
+struct AAX_Plugin_Desc
+{
+	const char* mEffectID; // unique for each channel layout as in "com.steinberg.aaxwrapper.mono"
+	const char* mName;
+	uint32 mPlugInIDNative; // unique for each channel layout
+	uint32 mPlugInIDAudioSuite; // unique for each channel layout
+
+	int32 mInputChannels;
+	int32 mOutputChannels;
+	int32 mSideChainInputChannels;
+
+	AAX_MIDI_Desc* mMIDIports;
+	AAX_Aux_Desc* mAuxOutputChannels; // zero terminated
+	AAX_Meter_Desc* mMeters;
+
+	uint32 mLatency;
+};
+
+struct AAX_Effect_Desc
+{
+	const char* mManufacturer;
+	const char* mProduct;
+
+	uint32 mManufacturerID;
+	uint32 mProductID;
+	const char* mCategory;
+	TUID mVST3PluginID;
+	uint32 mVersion;
+
+	const char* mPageFile;
+
+	AAX_Plugin_Desc* mPluginDesc;
+};
+
+// reference this in the Plug-In to force inclusion of the wrapper in the link
+extern int AAXWrapper_linkAnchor;
+
+AAX_Effect_Desc* AAXWrapper_GetDescription (); // to be defined by the Plug-In
+
+/// \endcond

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxwrapper_gui.cpp

@@ -0,0 +1,135 @@
+//------------------------------------------------------------------------
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxwrapper_gui.cpp
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses. 
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundef-prefix"
+#endif
+
+#include "aaxwrapper_gui.h"
+#include "aaxwrapper.h"
+#include "aaxwrapper_parameters.h"
+
+#include "AAX_IViewContainer.h"
+
+using namespace Steinberg;
+using namespace Steinberg::Vst;
+using namespace Steinberg::Base::Thread;
+
+//------------------------------------------------------------------------
+void AAXWrapper_GUI::CreateViewContainer ()
+{
+	if (GetViewContainerType () == AAX_eViewContainer_Type_HWND ||
+	    GetViewContainerType () == AAX_eViewContainer_Type_NSView)
+	{
+		mHWND = this->GetViewContainerPtr ();
+		AAXWrapper* wrapper =
+		    static_cast<AAXWrapper_Parameters*> (GetEffectParameters ())->getWrapper ();
+
+		FGuard guard (wrapper->mSyncCalls);
+		wrapper->setGUI (this);
+		mInOpen = true;
+		if (auto* editor = wrapper->getEditor ())
+			editor->_open (mHWND);
+		mInOpen = false;
+	}
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_GUI::GetViewSize (AAX_Point* oEffectViewSize) const
+{
+	oEffectViewSize->horz = 1024;
+	oEffectViewSize->vert = 768;
+
+	auto* that = const_cast<AAXWrapper_GUI*> (this);
+	auto* params = static_cast<AAXWrapper_Parameters*> (that->GetEffectParameters ());
+	int32 width, height;
+	if (params->getWrapper ()->getEditorSize (width, height))
+	{
+		oEffectViewSize->horz = static_cast<float> (width);
+		oEffectViewSize->vert = static_cast<float> (height);
+	}
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_GUI::SetControlHighlightInfo (AAX_CParamID iParameterID,
+                                                    AAX_CBoolean /*iIsHighlighted*/,
+                                                    AAX_EHighlightColor /*iColor*/)
+{	
+	AAXWrapper* wrapper =
+		static_cast<AAXWrapper_Parameters*> (GetEffectParameters ())->getWrapper ();
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == kNoParamId)
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+
+	// TODO
+	wrapper;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+void AAXWrapper_GUI::DeleteViewContainer ()
+{
+	AAXWrapper* wrapper =
+	    static_cast<AAXWrapper_Parameters*> (GetEffectParameters ())->getWrapper ();
+	wrapper->setGUI (nullptr);
+
+	if (auto* editor = wrapper->getEditor ())
+		editor->_close ();
+}
+
+//------------------------------------------------------------------------
+// METHOD:	CreateViewContents
+//------------------------------------------------------------------------
+void AAXWrapper_GUI::CreateViewContents ()
+{
+}
+
+//------------------------------------------------------------------------
+bool AAXWrapper_GUI::setWindowSize (AAX_Point& size)
+{
+	if (mInOpen)
+		mRefreshSize = true; // redo later, resizing might silently not work during opening the UI
+
+	if (AAX_IViewContainer* vc = GetViewContainer ())
+		if (vc->SetViewSize (size) == AAX_SUCCESS)
+			return true;
+
+	return false;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_GUI::TimerWakeup ()
+{
+	if (mRefreshSize)
+	{
+		mRefreshSize = false;
+		AAX_Point size;
+		if (GetViewSize (&size) == AAX_SUCCESS)
+			if (!setWindowSize (size))
+				mRefreshSize = true;
+	}
+	return AAX_CEffectGUI::TimerWakeup ();
+}
+/// \endcond
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxwrapper_gui.h

@@ -0,0 +1,53 @@
+//------------------------------------------------------------------------
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxwrapper_gui.h
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses. 
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+#pragma once
+
+#include "AAX_CEffectGUI.h"
+#include "pluginterfaces/base/fplatform.h"
+
+//==============================================================================
+class AAXWrapper_GUI : public AAX_CEffectGUI
+{
+public:
+	static AAX_IEffectGUI* AAX_CALLBACK Create ();
+
+	AAXWrapper_GUI () = default;
+	virtual ~AAXWrapper_GUI () = default;
+
+	void CreateViewContents () SMTG_OVERRIDE;
+	void CreateViewContainer () SMTG_OVERRIDE;
+	void DeleteViewContainer () SMTG_OVERRIDE;
+
+	AAX_Result GetViewSize (AAX_Point* oEffectViewSize) const SMTG_OVERRIDE;
+
+	AAX_Result SetControlHighlightInfo (AAX_CParamID /* iParameterID */,
+	                                    AAX_CBoolean /* iIsHighlighted */,
+	                                    AAX_EHighlightColor /* iColor */) SMTG_OVERRIDE;
+
+	AAX_Result TimerWakeup () SMTG_OVERRIDE;
+
+	bool setWindowSize (AAX_Point& size); // calback from AAXWrapper
+
+private:
+	bool mInOpen = false;
+	bool mRefreshSize = false;
+	void* mHWND = nullptr;
+};
+
+/// \endcond

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxwrapper_parameters.cpp

@@ -0,0 +1,858 @@
+//------------------------------------------------------------------------
+// Flags       : clang-format auto
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxwrapper_parameters.cpp
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses.
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+#include "aaxwrapper_parameters.h"
+#include "aaxwrapper.h"
+#include "aaxwrapper_description.h"
+
+#include "AAX_CBinaryDisplayDelegate.h"
+#include "AAX_CBinaryTaperDelegate.h"
+#include "AAX_CLinearTaperDelegate.h"
+#include "AAX_CNumberDisplayDelegate.h"
+#include "AAX_CUnitDisplayDelegateDecorator.h"
+
+#include "../hosting/hostclasses.h"
+#include "pluginterfaces/base/funknownimpl.h"
+#include "pluginterfaces/base/futils.h"
+#include "pluginterfaces/vst/ivstaudioprocessor.h"
+#include "pluginterfaces/vst/ivstchannelcontextinfo.h"
+
+using namespace Steinberg;
+using namespace Steinberg::Vst;
+using namespace Steinberg::Base::Thread;
+
+#define USE_TRACE 1
+
+#if USE_TRACE
+#define HAPI AAX_eTracePriorityHost_Normal
+#define HLOG AAX_TRACE
+
+#else
+#define HAPI 0
+#if SMTG_OS_WINDOWS
+#define HLOG __noop
+#else
+#define HLOG(...) \
+	do            \
+	{             \
+	} while (false)
+#endif
+#endif
+
+SMTG_EXPORT_SYMBOL IPluginFactory* PLUGIN_API GetPluginFactory ();
+
+const char* kBypassId = "Byp";
+
+ParameterInfo kParamInfoBypass = {CCONST ('B', 'y', 'p', 0),
+                                  STR ("Bypass"),
+                                  STR ("Bypass"),
+                                  STR (""),
+                                  1,
+                                  0,
+                                  -1,
+                                  Vst::ParameterInfo::kCanAutomate | Vst::ParameterInfo::kIsBypass};
+
+//------------------------------------------------------------------------
+// AAXWrapper_Parameters
+//------------------------------------------------------------------------
+AAXWrapper_Parameters::AAXWrapper_Parameters (int32_t plugIndex)
+: AAX_CEffectParameters (), mSimulateBypass (false)
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	AAX_Effect_Desc* effDesc = AAXWrapper_GetDescription ();
+	mPluginDesc = effDesc->mPluginDesc + plugIndex;
+	mWrapper = AAXWrapper::create (GetPluginFactory (), effDesc->mVST3PluginID, mPluginDesc, this);
+	if (!mWrapper)
+		return;
+
+#if DEVELOPMENT
+	static bool writePagetableFile;
+	if (writePagetableFile) // use debugger to set variable or jump into function
+		mWrapper->generatePageTables ("c:/tmp/pagetable.xml");
+#endif
+
+	// if no VST3 Bypass found then simulate it
+	mSimulateBypass = (mWrapper->mBypassParameterID == Vst::kNoParamId);
+	mWrapper->mSimulateBypass = mSimulateBypass;
+
+	if (mParamNames.size () < (size_t)mWrapper->mNumParams)
+	{
+		mParamNames.resize (mWrapper->mNumParams);
+		for (size_t i = 0; i < mParamNames.size (); i++)
+			mParamNames[i].set (mWrapper->mParameterMap[i].vst3ID);
+	}
+}
+
+//------------------------------------------------------------------------
+AAXWrapper_Parameters::~AAXWrapper_Parameters ()
+{
+	delete mWrapper;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::EffectInit ()
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	if (AAX_IController* ctrl = Controller ())
+	{
+		AAX_CSampleRate sampleRate;
+		if (ctrl->GetSampleRate (&sampleRate) == AAX_SUCCESS)
+			mWrapper->_setSampleRate (sampleRate);
+		if (mWrapper->mProcessor)
+			ctrl->SetSignalLatency (
+			    static_cast<int32> (mWrapper->mProcessor->getLatencySamples ()));
+	}
+
+	for (uint32 i = 0; i < static_cast<uint32> (mWrapper->mNumParams); i++)
+	{
+		AAX_CParamID iParameterID = mParamNames[i];
+		ParameterInfo paramInfo = {};
+		if (AAX_Result result = mWrapper->getParameterInfo (iParameterID, paramInfo))
+			return result;
+
+		String title = paramInfo.title;
+		AAX_IParameter* param = nullptr;
+		param = NEW AAX_CParameter<double> (
+		    iParameterID, AAX_CString (title), paramInfo.defaultNormalizedValue,
+		    AAX_CLinearTaperDelegate<double> (0, 1),
+		    AAX_CUnitDisplayDelegateDecorator<double> (AAX_CNumberDisplayDelegate<double> (),
+		                                               AAX_CString (title)),
+		    true);
+
+		mParameterManager.AddParameter (param);
+	}
+
+	if (mSimulateBypass)
+	{
+		AAX_IParameter* param = NEW AAX_CParameter<bool> (
+		    kBypassId, AAX_CString ("Bypass"), false, AAX_CBinaryTaperDelegate<bool> (),
+		    AAX_CBinaryDisplayDelegate<bool> ("off", "on"), true);
+
+		mParameterManager.AddParameter (param);
+	}
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::ResetFieldData (AAX_CFieldIndex index, void* inData,
+                                                  uint32_t inDataSize) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	return mWrapper->ResetFieldData (index, inData, inDataSize);
+}
+
+//------------------------------------------------------------------------
+// METHOD:	AAX_UpdateMIDINodes
+// This will be called by the host if there are MIDI packets that need
+// to be handled in the Data Model.
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::UpdateMIDINodes (AAX_CFieldIndex inFieldIndex,
+                                                   AAX_CMidiPacket& inPacket)
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	AAX_Result result;
+	result = AAX_SUCCESS;
+
+	inFieldIndex;
+	inPacket;
+	// Do some MIDI work if necessary.
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+int32 AAXWrapper_Parameters::getParameterInfo (AAX_CParamID aaxId,
+                                               Vst::ParameterInfo& paramInfo) const
+{
+	AAX_Result result = mWrapper->getParameterInfo (aaxId, paramInfo);
+	if (result != AAX_SUCCESS)
+	{
+		if (mSimulateBypass && strcmp (aaxId, kBypassId) == 0)
+		{
+			paramInfo = kParamInfoBypass;
+			result = AAX_SUCCESS;
+		}
+	}
+	return result;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetNumberOfParameters (int32_t* oNumControls) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+	*oNumControls = mWrapper->mNumParams;
+	if (mSimulateBypass)
+		*oNumControls += 1;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetMasterBypassParameter (AAX_IString* oIDString) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	*oIDString = mSimulateBypass ? kBypassId : AAX_CID (mWrapper->mBypassParameterID);
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterIsAutomatable (AAX_CParamID iParameterID,
+                                                             AAX_CBoolean* oAutomatable) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	ParameterInfo paramInfo = {};
+	if (AAX_Result result = getParameterInfo (iParameterID, paramInfo))
+		return result;
+
+	*oAutomatable = (paramInfo.flags & ParameterInfo::kCanAutomate) != 0;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterNumberOfSteps (AAX_CParamID iParameterID,
+                                                             int32_t* oNumSteps) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	ParameterInfo paramInfo = {};
+	if (AAX_Result result = getParameterInfo (iParameterID, paramInfo))
+		return result;
+
+	if (paramInfo.stepCount == 0)
+		*oNumSteps = 1024;
+	else
+		*oNumSteps = paramInfo.stepCount + 1;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterName (AAX_CParamID iParameterID,
+                                                    AAX_IString* oName) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	ParameterInfo paramInfo = {};
+	if (AAX_Result result = getParameterInfo (iParameterID, paramInfo))
+		return result;
+
+	*oName = String (paramInfo.title);
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterNameOfLength (AAX_CParamID iParameterID,
+                                                            AAX_IString* oName,
+                                                            int32_t iNameLength) const
+{
+	HLOG (HAPI, "%s(id=%s, len=%d)", __FUNCTION__, iParameterID, iNameLength);
+
+	ParameterInfo paramInfo = {};
+	if (AAX_Result result = getParameterInfo (iParameterID, paramInfo))
+		return result;
+
+	if (iNameLength >= tstrlen (paramInfo.title))
+		*oName = String (paramInfo.title);
+	else
+	{
+		if (iNameLength < tstrlen (paramInfo.shortTitle))
+			paramInfo.shortTitle[iNameLength] = 0;
+		*oName = String (paramInfo.shortTitle);
+	}
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterDefaultNormalizedValue (AAX_CParamID iParameterID,
+                                                                      double* oValue) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	ParameterInfo paramInfo = {};
+	if (AAX_Result result = getParameterInfo (iParameterID, paramInfo))
+		return result;
+
+	*oValue = paramInfo.defaultNormalizedValue;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::SetParameterDefaultNormalizedValue (AAX_CParamID iParameterID,
+                                                                      double iValue)
+{
+	iParameterID;
+	iValue;
+	HLOG (HAPI, "%s(id=%s, value=%lf)", __FUNCTION__, iParameterID, iValue);
+
+	return AAX_ERROR_UNIMPLEMENTED;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterType (AAX_CParamID iParameterID,
+                                                    AAX_EParameterType* oParameterType) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	ParameterInfo paramInfo = {};
+	if (AAX_Result result = getParameterInfo (iParameterID, paramInfo))
+		return result;
+	*oParameterType =
+	    paramInfo.stepCount == 0 ? AAX_eParameterType_Continuous : AAX_eParameterType_Discrete;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterOrientation (
+    AAX_CParamID iParameterID, AAX_EParameterOrientation* oParameterOrientation) const
+{
+	iParameterID;
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	*oParameterOrientation = AAX_eParameterOrientation_BottomMinTopMax; // we don't care
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameter (AAX_CParamID iParameterID,
+                                                AAX_IParameter** /*oParameter*/)
+{
+	iParameterID;
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	SMTG_ASSERT (!"the host is not supposed to retrieve the AAX_IParameter interface");
+	return AAX_ERROR_UNIMPLEMENTED;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterIndex (AAX_CParamID iParameterID,
+                                                     int32_t* oControlIndex) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == -1)
+	{
+		if (mSimulateBypass && strcmp (iParameterID, kBypassId) == 0)
+		{
+			*oControlIndex = mWrapper->mNumParams;
+			return AAX_SUCCESS;
+		}
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+	}
+
+	*oControlIndex = -1;
+	int32_t idx = 0;
+	for (auto& item : mParamNames)
+	{
+		if (strcmp (item, iParameterID) == 0)
+		{
+			*oControlIndex = idx;
+			return AAX_SUCCESS;
+		}
+		idx++;
+	}
+	return AAX_ERROR_INVALID_PARAMETER_ID;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterIDFromIndex (int32_t iControlIndex,
+                                                           AAX_IString* oParameterIDString) const
+{
+	HLOG (HAPI, "%s(idx=%x)", __FUNCTION__, iControlIndex);
+
+	if ((size_t)iControlIndex >= mWrapper->mParameterMap.size ())
+	{
+		if (mSimulateBypass && iControlIndex == mWrapper->mNumParams)
+		{
+			oParameterIDString->Set (kBypassId);
+			return AAX_SUCCESS;
+		}
+		return AAX_ERROR_INVALID_PARAMETER_INDEX;
+	}
+
+	*oParameterIDString = mParamNames[iControlIndex];
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterValueInfo (AAX_CParamID iParameterID,
+                                                         int32_t /*iSelector*/,
+                                                         int32_t* oValue) const
+{
+	iParameterID;
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	*oValue = 0;
+	return AAX_ERROR_UNIMPLEMENTED;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterValueFromString (
+    AAX_CParamID iParameterID, double* oValue, const AAX_IString& iValueString) const
+{
+	HLOG (HAPI, "%s(id=%s, string=%s)", __FUNCTION__, iParameterID, iValueString.Get ());
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == -1)
+	{
+		if (mSimulateBypass && strcmp (iParameterID, kBypassId) == 0)
+		{
+			*oValue = strcmp (iValueString.Get (), "on") == 0;
+			return AAX_SUCCESS;
+		}
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+	}
+	String tmp (iValueString.Get ());
+	if (mWrapper->mController->getParamValueByString (id, (Vst::TChar*)tmp.text16 (), *oValue) !=
+	    kResultTrue)
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterStringFromValue (AAX_CParamID iParameterID,
+                                                               double iValue,
+                                                               AAX_IString* oValueString,
+                                                               int32_t maxLength) const
+{
+	HLOG (HAPI, "%s(id=%s, value=%lf)", __FUNCTION__, iParameterID, iValue);
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == -1)
+	{
+		if (mSimulateBypass && strcmp (iParameterID, kBypassId) == 0)
+		{
+			oValueString->Set (iValue >= 0.5 ? "on" : "off");
+			return AAX_SUCCESS;
+		}
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+	}
+
+	String128 tmp = {0};
+	if (mWrapper->mController->getParamStringByValue (id, iValue, tmp) != kResultTrue)
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+
+	if (maxLength < tstrlen (tmp))
+		tmp[maxLength] = 0;
+	*oValueString = String (tmp);
+	//		String str (tmp);
+	//		str.copyTo8 (text, 0, kVstMaxParamStrLen);
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterValueString (AAX_CParamID iParameterID,
+                                                           AAX_IString* oValueString,
+                                                           int32_t iMaxLength) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	double value;
+	if (AAX_Result result = GetParameterNormalizedValue (iParameterID, &value))
+		return result;
+
+	return GetParameterStringFromValue (iParameterID, value, oValueString, iMaxLength);
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetParameterNormalizedValue (AAX_CParamID iParameterID,
+                                                               double* oValuePtr) const
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == -1)
+	{
+		if (mSimulateBypass && strcmp (iParameterID, kBypassId) == 0)
+		{
+			*oValuePtr = (mWrapper->mBypass ? 1 : 0);
+			return AAX_SUCCESS;
+		}
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+	}
+
+	ParamValue value = 0;
+	if (!mWrapper->getLastParamChange (id, value))
+		value = mWrapper->mController->getParamNormalized (id);
+	*oValuePtr = value;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::SetParameterNormalizedValue (AAX_CParamID iParameterID,
+                                                               double iValue)
+{
+	HLOG (HAPI, "%s(id=%s, value=%lf)", __FUNCTION__, iParameterID, iValue);
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == -1)
+	{
+		if (mSimulateBypass && strcmp (iParameterID, kBypassId) == 0)
+			return AAX_SUCCESS;
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+	}
+
+	// mWrapper->addParameterChange (id, iValue, 0);
+
+	if (auto ad = AutomationDelegate ())
+	{
+		// Touch the control, Send that token, Release the control
+		ad->PostTouchRequest (iParameterID);
+		ad->PostSetValueRequest (iParameterID, iValue);
+		ad->PostReleaseRequest (iParameterID);
+	}
+
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::SetParameterNormalizedRelative (AAX_CParamID iParameterID,
+                                                                  double iValue)
+{
+	HLOG (HAPI, "%s(id=%s, value=%lf)", __FUNCTION__, iParameterID, iValue);
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == -1)
+	{
+		if (mSimulateBypass && strcmp (iParameterID, kBypassId) == 0)
+		{
+			mWrapper->mBypass = (mWrapper->mBypass + iValue >= 0.5);
+			mWrapper->_setBypass (mWrapper->mBypass);
+			return AAX_SUCCESS;
+		}
+		return AAX_ERROR_INVALID_PARAMETER_ID;
+	}
+
+	ParamValue value = 0;
+	if (!mWrapper->getLastParamChange (id, value))
+		value = mWrapper->mController->getParamNormalized (id);
+
+	value = value + iValue;
+	if (value < 0)
+		value = 0;
+	else if (value > 1)
+		value = 1;
+
+	SetParameterNormalizedValue (iParameterID, value);
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::TouchParameter (AAX_CParamID iParameterID)
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	if (auto ad = AutomationDelegate ())
+		return ad->PostTouchRequest (iParameterID);
+
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::ReleaseParameter (AAX_CParamID iParameterID)
+{
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	if (auto ad = AutomationDelegate ())
+		return ad->PostReleaseRequest (iParameterID);
+
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::UpdateParameterTouch (AAX_CParamID iParameterID,
+                                                        AAX_CBoolean /*iTouchState*/)
+{
+	iParameterID;
+	HLOG (HAPI, "%s(id=%s)", __FUNCTION__, iParameterID);
+
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::UpdateParameterNormalizedValue (AAX_CParamID iParameterID,
+                                                                  double iValue,
+                                                                  AAX_EUpdateSource iSource)
+{
+	HLOG (HAPI, "%s(id=%s, value=%lf)", __FUNCTION__, iParameterID, iValue);
+
+	Vst::ParamID id = getVstParamID (iParameterID);
+	if (id == -1)
+	{
+		if (mSimulateBypass && strcmp (iParameterID, kBypassId) == 0)
+		{
+			mWrapper->mBypass = iValue >= 0.5;
+			mWrapper->_setBypass (mWrapper->mBypass);
+		}
+		else
+			return AAX_ERROR_INVALID_PARAMETER_ID;
+	}
+	else
+		mWrapper->addParameterChange (id, iValue, 0);
+#if 1
+	return AAX_CEffectParameters::UpdateParameterNormalizedValue (iParameterID, iValue, iSource);
+#else
+	if (AutomationDelegate ())
+		AutomationDelegate ()->PostCurrentValue (iParameterID, iValue);
+
+	// if (AAX_Result result = SetParameterNormalizedValue (iParameterID, iValue))
+	//	return result;
+
+	// Now the control has changed
+	AAX_Result result = mPacketDispatcher.SetDirty (iParameterID);
+
+	++mNumPlugInChanges;
+	return result;
+#endif
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::_UpdateParameterNormalizedRelative (AAX_CParamID iParameterID,
+                                                                      double iValue)
+{
+	HLOG (HAPI, "%s(id=%s, value=%lf)", __FUNCTION__, iParameterID, iValue);
+
+	if (AAX_Result result = SetParameterNormalizedRelative (iParameterID, iValue))
+		return result;
+
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::_GenerateCoefficients ()
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	AAX_Result result = mPacketDispatcher.Dispatch ();
+
+	return result;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetNumberOfChunks (int32_t* numChunks) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	*numChunks = 1;
+	return AAX_SUCCESS;
+}
+
+const AAX_CTypeID AAXWRAPPER_CONTROLS_CHUNK_ID = CCONST ('a', 'w', 'c', 'k');
+const char AAXWRAPPER_CONTROLS_CHUNK_DESCRIPTION[] = "AAXWrapper State";
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetChunkIDFromIndex (int32_t index, AAX_CTypeID* chunkID) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	if (index != 0)
+		return AAX_ERROR_INVALID_CHUNK_INDEX;
+
+	*chunkID = AAXWRAPPER_CONTROLS_CHUNK_ID;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetChunkSize (AAX_CTypeID chunkID, uint32_t* oSize) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	if (chunkID != AAXWRAPPER_CONTROLS_CHUNK_ID)
+		return AAX_ERROR_INVALID_CHUNK_ID;
+
+	FGuard guard (mWrapper->mSyncCalls);
+	bool isPreset = false;
+	void* data;
+	*oSize = static_cast<uint32> (mWrapper->_getChunk (&data, isPreset));
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::GetChunk (AAX_CTypeID chunkID, AAX_SPlugInChunk* oChunk) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	if (chunkID != AAXWRAPPER_CONTROLS_CHUNK_ID)
+		return AAX_ERROR_INVALID_CHUNK_ID;
+
+	FGuard guard (mWrapper->mSyncCalls);
+	// assume GetChunkSize called before and size of oChunk correct
+	oChunk->fVersion = 1;
+	oChunk->fSize = static_cast<int32_t> (mWrapper->mChunk.getSize ());
+	memcpy (oChunk->fData, mWrapper->mChunk.getData (),
+	        static_cast<size_t> (mWrapper->mChunk.getSize ()));
+	strncpy (reinterpret_cast<char*> (oChunk->fName), AAXWRAPPER_CONTROLS_CHUNK_DESCRIPTION, 31);
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::SetChunk (AAX_CTypeID chunkID, const AAX_SPlugInChunk* iChunk)
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	if (chunkID != AAXWRAPPER_CONTROLS_CHUNK_ID)
+		return AAX_ERROR_INVALID_CHUNK_ID;
+
+	FGuard guard (mWrapper->mSyncCalls);
+	bool isPreset = mPresetOpened;
+	mWrapper->_setChunk (const_cast<char*> (iChunk->fData), iChunk->fSize, isPreset);
+	mPresetOpened = false;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::CompareActiveChunk (const AAX_SPlugInChunk* /*iChunk*/,
+                                                      AAX_CBoolean* /*oIsEqual*/) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	return AAX_ERROR_UNIMPLEMENTED;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::_GetNumberOfChanges (int32_t* oValue) const
+{
+	HLOG (HAPI, "%s", __FUNCTION__);
+
+	*oValue = mNumPlugInChanges;
+	return AAX_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+void AAXWrapper_Parameters::setDirty (bool state)
+{
+	if (state)
+		mNumPlugInChanges++;
+}
+
+//------------------------------------------------------------------------
+AAX_Result AAXWrapper_Parameters::NotificationReceived (AAX_CTypeID iNotificationType,
+                                                        const void* iNotificationData,
+                                                        uint32_t iNotificationDataSize)
+{
+	switch (iNotificationType)
+	{
+		//--- Tell the plug-in about connection of the sidechain input
+		case AAX_eNotificationEvent_SideChainBeingConnected:
+			mWrapper->setSideChainEnable (true);
+			break;
+		//--- Tell the plug-in about disconnection of the sidechain
+		case AAX_eNotificationEvent_SideChainBeingDisconnected:
+			mWrapper->setSideChainEnable (false);
+			break;
+		//--- The host has changed its latency compensation for this plug-in instance.
+		case AAX_eNotificationEvent_SignalLatencyChanged:
+		{
+			int32_t outSample;
+			Controller ()->GetSignalLatency (&outSample);
+
+			if (mPluginDesc)
+				mPluginDesc->mLatency = static_cast<uint32> (outSample);
+
+			if (mWrapper->isActive ())
+			{
+				mWrapper->_suspend ();
+				mWrapper->_resume ();
+			}
+			break;
+		}
+		//--- Tell the plug-in that chunk data is coming from a TFX
+		case AAX_eNotificationEvent_PresetOpened:
+		{
+			// do not wanted to overwrite the bypass state when loading preset
+			double value;
+			if (GetParameterNormalizedValue (
+			        mSimulateBypass ? kBypassId : AAX_CID (mWrapper->mBypassParameterID), &value) ==
+			    AAX_SUCCESS)
+				mWrapper->mBypassBeforePresetChanged = (value >= 0.5);
+			mWrapper->mPresetChanged = true;
+			mPresetOpened = true;
+			break;
+		}
+		//--- Tell the plug-in that chunk data is coming from a PTX
+		case AAX_eNotificationEvent_SessionBeingOpened:
+		{
+			mPresetOpened = false;
+			break;
+		}
+		//--- Entering offline processing mode (i.e.offline bounce)
+		case AAX_eNotificationEvent_EnteringOfflineMode:
+		{
+			mWrapper->setRenderingOffline (true);
+			break;
+		}
+		//--- Exiting offline processing mode (i.e. offline bounce)
+		case AAX_eNotificationEvent_ExitingOfflineMode:
+		{
+			mWrapper->setRenderingOffline (false);
+			break;
+		}
+		//---  A string representing the path of the current session
+		case AAX_eNotificationEvent_SessionPathChanged:
+		{
+			AAX_CString str (*reinterpret_cast<const AAX_IString*> (iNotificationData));
+			mSessionPath = str.StdString ();
+			break;
+		}
+		//--- The current name of this plug-in instance's track
+		case AAX_eNotificationEvent_TrackNameChanged:
+		{
+			AAX_CString str (*reinterpret_cast<const AAX_IString*> (iNotificationData));
+			mChannelName = str.StdString ();
+
+			if (mWrapper->mController)
+			{
+				if (auto iChannelContextInfoListener =
+				        U::cast<Vst::ChannelContext::IInfoListener> (mWrapper->mController))
+				{
+					auto list = Vst::HostAttributeList::make ();
+					String string;
+					string.fromUTF8 (mChannelName.data ());
+
+					list->setString (Vst::ChannelContext::kChannelNameKey, string);
+					list->setInt (Vst::ChannelContext::kChannelNameLengthKey, string.length ());
+
+					iChannelContextInfoListener->setChannelContextInfos (list);
+				}
+			}
+			break;
+		}
+		//--- The zero-indexed insert position of this plug-in instance within its track
+		case AAX_eNotificationEvent_InsertPositionChanged:
+		{
+			//	auto tmp = *reinterpret_cast<const int32_t*> (iNotificationData);
+			break;
+		}
+		//--- Tell the plug-in the maximum allowed GUI dimensions
+		case AAX_eNotificationEvent_MaxViewSizeChanged:
+		{
+			//	auto tmp = *reinterpret_cast<const AAX_Point*> (iNotificationData);
+			break;
+		}
+	}
+
+	return AAX_CEffectParameters::NotificationReceived (iNotificationType, iNotificationData,
+	                                                    iNotificationDataSize);
+}
+
+/// \endcond

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/aaxwrapper_parameters.h

@@ -0,0 +1,157 @@
+//------------------------------------------------------------------------
+// Project     : VST SDK
+//
+// Category    : Helpers
+// Filename    : public.sdk/source/vst/aaxwrapper/aaxwrapper_parameters.h
+// Created by  : Steinberg, 08/2017
+// Description : VST 3 -> AAX Wrapper
+//
+//-----------------------------------------------------------------------------
+// This file is part of a Steinberg SDK. It is subject to the license terms
+// in the LICENSE file found in the top-level directory of this distribution
+// and at www.steinberg.net/sdklicenses. 
+// No part of the SDK, including this file, may be copied, modified, propagated,
+// or distributed except according to the terms contained in the LICENSE file.
+//-----------------------------------------------------------------------------
+
+/// \cond ignore
+
+#pragma once
+
+#include "public.sdk/source/vst/basewrapper/basewrapper.h"
+
+#include "AAX_CEffectParameters.h"
+#include "AAX_Push8ByteStructAlignment.h"
+
+class AAXWrapper;
+struct AAX_Plugin_Desc;
+
+//------------------------------------------------------------------------
+// helper to convert to/from AAX/Vst IDs
+struct AAX_CID
+{
+	char str[10] {0};
+	AAX_CID () {}
+	AAX_CID (Steinberg::Vst::ParamID id) { set (id); }
+	void set (Steinberg::Vst::ParamID id) { snprintf (str, 10, "p%lX", static_cast<unsigned long> (id)); }
+	operator const char* () const { return str; }
+};
+
+Steinberg::Vst::ParamID getVstParamID (const char* aaxid);
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wignored-attributes"
+#pragma clang diagnostic ignored "-Wincompatible-ms-struct"
+#endif
+
+//------------------------------------------------------------------------
+class AAXWrapper_Parameters : public AAX_CEffectParameters
+{
+public:
+	// Constructor
+	AAXWrapper_Parameters (int32_t plugIndex);
+	~AAXWrapper_Parameters ();
+
+	static AAX_CEffectParameters* AAX_CALLBACK Create ();
+
+	// Overrides from AAX_CEffectParameters
+	AAX_Result EffectInit () SMTG_OVERRIDE;
+	AAX_Result ResetFieldData (AAX_CFieldIndex index, void* inData,
+	                           uint32_t inDataSize) const SMTG_OVERRIDE;
+	AAX_Result NotificationReceived (AAX_CTypeID iNotificationType, const void* iNotificationData,
+	                                 uint32_t iNotificationDataSize) SMTG_OVERRIDE;
+
+	/* Parameter information */
+	AAX_Result GetNumberOfParameters (int32_t* oNumControls) const SMTG_OVERRIDE;
+	AAX_Result GetMasterBypassParameter (AAX_IString* oIDString) const SMTG_OVERRIDE;
+	AAX_Result GetParameterIsAutomatable (AAX_CParamID iParameterID,
+	                                      AAX_CBoolean* oAutomatable) const SMTG_OVERRIDE;
+	AAX_Result GetParameterNumberOfSteps (AAX_CParamID iParameterID,
+	                                      int32_t* oNumSteps) const SMTG_OVERRIDE;
+	AAX_Result GetParameterName (AAX_CParamID iParameterID, AAX_IString* oName) const SMTG_OVERRIDE;
+	AAX_Result GetParameterNameOfLength (AAX_CParamID iParameterID, AAX_IString* oName,
+	                                     int32_t iNameLength) const SMTG_OVERRIDE;
+	AAX_Result GetParameterDefaultNormalizedValue (AAX_CParamID iParameterID,
+	                                               double* oValue) const SMTG_OVERRIDE;
+	AAX_Result SetParameterDefaultNormalizedValue (AAX_CParamID iParameterID,
+	                                               double iValue) SMTG_OVERRIDE;
+	AAX_Result GetParameterType (AAX_CParamID iParameterID,
+	                             AAX_EParameterType* oParameterType) const SMTG_OVERRIDE;
+	AAX_Result GetParameterOrientation (AAX_CParamID iParameterID,
+	                                    AAX_EParameterOrientation* oParameterOrientation) const
+	    SMTG_OVERRIDE;
+	AAX_Result GetParameter (AAX_CParamID iParameterID, AAX_IParameter** oParameter) SMTG_OVERRIDE;
+	AAX_Result GetParameterIndex (AAX_CParamID iParameterID,
+	                              int32_t* oControlIndex) const SMTG_OVERRIDE;
+	AAX_Result GetParameterIDFromIndex (int32_t iControlIndex,
+	                                    AAX_IString* oParameterIDString) const SMTG_OVERRIDE;
+	AAX_Result GetParameterValueInfo (AAX_CParamID iParameterID, int32_t iSelector,
+	                                  int32_t* oValue) const SMTG_OVERRIDE;
+
+	/** Parameter setters and getters */
+	AAX_Result GetParameterValueFromString (AAX_CParamID iParameterID, double* oValue,
+	                                        const AAX_IString& iValueString) const SMTG_OVERRIDE;
+	AAX_Result GetParameterStringFromValue (AAX_CParamID iParameterID, double iValue,
+	                                        AAX_IString* oValueString,
+	                                        int32_t maxLength) const SMTG_OVERRIDE;
+	AAX_Result GetParameterValueString (AAX_CParamID iParameterID, AAX_IString* oValueString,
+	                                    int32_t iMaxLength) const SMTG_OVERRIDE;
+	AAX_Result GetParameterNormalizedValue (AAX_CParamID iParameterID,
+	                                        double* oValuePtr) const SMTG_OVERRIDE;
+	AAX_Result SetParameterNormalizedValue (AAX_CParamID iParameterID, double iValue) SMTG_OVERRIDE;
+	AAX_Result SetParameterNormalizedRelative (AAX_CParamID iParameterID,
+	                                           double iValue) SMTG_OVERRIDE;
+
+	/* Automated parameter helpers */
+	AAX_Result TouchParameter (AAX_CParamID iParameterID) SMTG_OVERRIDE;
+	AAX_Result ReleaseParameter (AAX_CParamID iParameterID) SMTG_OVERRIDE;
+	AAX_Result UpdateParameterTouch (AAX_CParamID iParameterID,
+	                                 AAX_CBoolean iTouchState) SMTG_OVERRIDE;
+
+	/* Asynchronous parameter update methods */
+	AAX_Result UpdateParameterNormalizedValue (AAX_CParamID iParameterID, double iValue,
+	                                           AAX_EUpdateSource iSource) SMTG_OVERRIDE;
+	AAX_Result _UpdateParameterNormalizedRelative (AAX_CParamID iParameterID, double iValue);
+	AAX_Result _GenerateCoefficients ();
+
+	/* Chunk methods */
+	AAX_Result GetNumberOfChunks (int32_t* numChunks) const SMTG_OVERRIDE;
+	AAX_Result GetChunkIDFromIndex (int32_t index, AAX_CTypeID* chunkID) const SMTG_OVERRIDE;
+	AAX_Result GetChunkSize (AAX_CTypeID chunkID, uint32_t* oSize) const SMTG_OVERRIDE;
+	AAX_Result GetChunk (AAX_CTypeID chunkID, AAX_SPlugInChunk* oChunk) const SMTG_OVERRIDE;
+	AAX_Result SetChunk (AAX_CTypeID chunkID, const AAX_SPlugInChunk* iChunk) SMTG_OVERRIDE;
+	AAX_Result CompareActiveChunk (const AAX_SPlugInChunk* iChunk,
+	                               AAX_CBoolean* oIsEqual) const SMTG_OVERRIDE;
+	AAX_Result _GetNumberOfChanges (int32_t* oValue) const;
+
+	// Override this method to receive MIDI
+	// packets for the described MIDI nodes
+	AAX_Result UpdateMIDINodes (AAX_CFieldIndex inFieldIndex,
+	                            AAX_CMidiPacket& inPacket) SMTG_OVERRIDE;
+
+	AAXWrapper* getWrapper () { return mWrapper; }
+	void setDirty (bool state);
+
+private:
+	Steinberg::int32 getParameterInfo (AAX_CParamID aaxId,
+	                                   Steinberg::Vst::ParameterInfo& paramInfo) const;
+
+	AAXWrapper* mWrapper = nullptr;
+	std::vector<AAX_CID> mParamNames;
+
+	AAX_Plugin_Desc* mPluginDesc = nullptr;
+	std::string mChannelName;
+	std::string mSessionPath;
+
+	bool mSimulateBypass = false;
+	bool mPresetOpened = false;
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#include "AAX_PopStructAlignment.h"
+
+/// \endcond

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/resource/PreBuildEvent.bat

@@ -0,0 +1,30 @@
+set OutDir=%1
+
+if not exist %OutDir%\..\..\Contents mkdir %OutDir%\..\..\Contents
+if errorlevel 1 goto err
+if not exist %OutDir%\..\..\Contents\Resources mkdir %OutDir%\..\..\Contents\Resources
+if errorlevel 1 goto err
+
+echo Copy "aaxwrapperPages.xml"
+copy /Y ..\resource\aaxwrapperPages.xml %OutDir%\..\..\Contents\Resources\ > NUL
+if errorlevel 1 goto err
+
+attrib -r %OutDir%\..\..
+
+if exist %OutDir%\..\..\PlugIn.ico goto PlugIn_ico_exists
+copy /Y ..\resource\PlugIn.ico %OutDir%\..\..\ > NUL
+if errorlevel 1 goto err
+attrib +h +r +s %OutDir%\..\..\PlugIn.ico
+if errorlevel 1 goto err
+:PlugIn_ico_exists
+
+if exist %OutDir%\..\..\desktop.ini goto desktop_ini_exists
+copy /Y ..\resource\desktop.ini %OutDir%\..\..\ > NUL
+if errorlevel 1 goto err
+attrib +h +r +s %OutDir%\..\..\desktop.ini
+if errorlevel 1 goto err
+:desktop_ini_exists
+
+attrib +r %OutDir%\..\..
+
+:err

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/resource/aaxwrapper.rc

@@ -0,0 +1,102 @@
+// Microsoft Visual C++ generated resource script.
+//
+
+#define APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "DemoMIDIResource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,0,1
+ PRODUCTVERSION 7,0,0,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "AAXWrapper Plug-In"
+            VALUE "FileVersion", "1.0.0.0"
+            VALUE "InternalName", "AAXWrapper.aaxplugin"
+            VALUE "LegalCopyright", "(c) Steinberg Media Technologies 2020"
+            VALUE "OriginalFilename", "AAXWrapper.aaxplugin"
+            VALUE "ProductName", "AAX Wrapper"
+            VALUE "ProductVersion", "0.1"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/resource/aaxwrapperPages.xml

@@ -0,0 +1,135 @@
+<?xml version='1.0' encoding='US-ASCII' standalone='yes'?>
+<PageTables vers='6.4.0.89'>
+	<PageTableLayouts>
+		<Plugin manID='AVID' prodID='DmGn' plugID='DGDR'>
+			<Desc>DemoGain 1 -&gt; 1 by Avid Inc.</Desc>
+			<Layout>PageTable 1</Layout>
+		</Plugin><!--manID='AVID' prodID='DmGn' plugID='DGDR'-->
+		<PTLayout name='PageTable 1'>
+			<PageTable type='PgTL' pgsz='1'>
+				<Page num='1'>
+					<ID>MasterBypass</ID>
+				</Page><!--num='1'-->
+				<Page num='2'>
+					<ID>Gain</ID>
+				</Page><!--num='2'-->
+			</PageTable><!--type='PgTL' pgsz='1'-->
+			<PageTable type='MkTL' pgsz='8'>
+				<Page num='1'>
+					<ID></ID>
+					<ID>Gain</ID>
+					<ID>MasterBypass</ID>
+				</Page><!--num='1'-->
+				<FirstPg cat='0'>1</FirstPg>
+				<FirstPg cat='1'>1</FirstPg>
+				<FirstPg cat='2'>1</FirstPg>
+				<FirstPg cat='4'>1</FirstPg>
+				<FirstPg cat='8'>1</FirstPg>
+				<FirstPg cat='16'>1</FirstPg>
+				<FirstPg cat='32'>1</FirstPg>
+				<FirstPg cat='64'>1</FirstPg>
+				<FirstPg cat='128'>1</FirstPg>
+				<FirstPg cat='256'>1</FirstPg>
+				<FirstPg cat='512'>1</FirstPg>
+				<FirstPg cat='1024'>1</FirstPg>
+				<FirstPg cat='2048'>1</FirstPg>
+			</PageTable><!--type='MkTL' pgsz='8'-->
+			<PageTable type='PcTL' pgsz='16'>
+				<Page num='1'>
+					<ID>MasterBypass</ID>
+					<ID>Gain </ID>
+				</Page><!--num='1'-->
+				<FirstPg cat='0'>1</FirstPg>
+				<FirstPg cat='1'>1</FirstPg>
+				<FirstPg cat='2'>1</FirstPg>
+				<FirstPg cat='4'>1</FirstPg>
+				<FirstPg cat='8'>1</FirstPg>
+				<FirstPg cat='16'>1</FirstPg>
+				<FirstPg cat='32'>1</FirstPg>
+				<FirstPg cat='64'>1</FirstPg>
+				<FirstPg cat='128'>1</FirstPg>
+				<FirstPg cat='256'>1</FirstPg>
+				<FirstPg cat='512'>1</FirstPg>
+				<FirstPg cat='1024'>1</FirstPg>
+				<FirstPg cat='2048'>1</FirstPg>
+			</PageTable><!--type='PcTL' pgsz='16'-->
+			<PageTable type='FrTL' pgsz='24'>
+				<Page num='1'>
+					<ID>MasterBypass</ID>
+					<ID>Gain</ID>
+				</Page><!--num='1'-->
+				<FirstPg cat='0'>1</FirstPg>
+				<FirstPg cat='1'>1</FirstPg>
+				<FirstPg cat='2'>1</FirstPg>
+				<FirstPg cat='4'>1</FirstPg>
+				<FirstPg cat='8'>1</FirstPg>
+				<FirstPg cat='16'>1</FirstPg>
+				<FirstPg cat='32'>1</FirstPg>
+				<FirstPg cat='64'>1</FirstPg>
+				<FirstPg cat='128'>1</FirstPg>
+				<FirstPg cat='256'>1</FirstPg>
+				<FirstPg cat='512'>1</FirstPg>
+				<FirstPg cat='1024'>1</FirstPg>
+				<FirstPg cat='2048'>1</FirstPg>
+			</PageTable><!--type='FrTL' pgsz='24'-->
+			<PageTable type='HgTL' pgsz='8'>
+				<Page num='1'>
+					<ID></ID>
+					<ID>Gain</ID>
+					<ID>MasterBypass</ID>
+				</Page><!--num='1'-->
+				<FirstPg cat='0'>1</FirstPg>
+				<FirstPg cat='1'>1</FirstPg>
+				<FirstPg cat='2'>1</FirstPg>
+				<FirstPg cat='4'>1</FirstPg>
+				<FirstPg cat='8'>1</FirstPg>
+				<FirstPg cat='16'>1</FirstPg>
+				<FirstPg cat='32'>1</FirstPg>
+				<FirstPg cat='64'>1</FirstPg>
+				<FirstPg cat='128'>1</FirstPg>
+				<FirstPg cat='256'>1</FirstPg>
+				<FirstPg cat='512'>1</FirstPg>
+				<FirstPg cat='1024'>1</FirstPg>
+				<FirstPg cat='2048'>1</FirstPg>
+			</PageTable><!--type='HgTL' pgsz='8'-->
+			<PageTable type='BkCS' pgsz='12'>
+				<Page num='1'>
+					<ID>MasterBypass</ID>
+					<ID>Gain</ID>
+				</Page><!--num='1'-->
+			</PageTable><!--type='BkCS' pgsz='12'-->
+			<PageTable type='BkSF' pgsz='16'>
+				<Page num='1'>
+					<ID>MasterBypass</ID>
+					<ID>Gain</ID>
+				</Page><!--num='1'-->
+			</PageTable><!--type='BkSF' pgsz='16'-->
+		</PTLayout><!--name='PageTable 1'-->
+	</PageTableLayouts>
+	<ControlNamesVariations>
+		<Ctrl ID='Gain'>
+			<name typ='PgTL' sz='1'>Ga</name>
+			<name typ='PgTL' sz='3'>Gn </name>
+		</Ctrl><!--ID='Gain'-->
+		<Ctrl ID='MasterBypass'>
+			<name typ='PgTL' sz='1'>Ma</name>
+			<name typ='PgTL' sz='3'>Byp</name>
+			<name typ='PgTL' sz='4'>MByp</name>
+			<name typ='PgTL' sz='8'>Mstr Byp</name>
+		</Ctrl><!--ID='MasterBypass'-->
+	</ControlNamesVariations>
+	<Editor vers='1.1.0.1'>
+		<PluginList>
+			<TDM>
+			</TDM>
+			<RTAS>
+				<PluginID manID='AVID' prodID='DmGn' plugID='DGDR'>
+					<MenuStr>RTAS: DemoGain, 1 in X 1 out</MenuStr>
+				</PluginID><!--manID='AVID' prodID='DmGn' plugID='DGDR'-->
+			</RTAS>
+		</PluginList>
+		<DiscCtrls>
+			<CtrlID>MasterBypass</CtrlID>
+		</DiscCtrls>
+	</Editor><!--vers='1.1.0.1'-->
+</PageTables><!--vers='6.4.0.89'-->

engine/vendor/vst3sdk/public.sdk/source/vst/aaxwrapper/resource/desktop.ini

@@ -0,0 +1,5 @@
+[.ShellClassInfo]  
+IconResource=PlugIn.ico,0  
+;For compatibility with Windows XP  
+IconFile=PlugIn.ico  
+IconIndex=0