Initial release

engine/vendor/vst3sdk/cmake/modules/SMTG_AAXSupport.cmake

@@ -0,0 +1,37 @@
+
+#------------------------------------------------------------------------
+function(setupAaxSupport)
+    # AAX SDK Location
+    if(SMTG_MAC OR SMTG_WIN)
+        if("${SMTG_AAX_SDK_PATH}" STREQUAL "")
+            # Check if the AAX SDK is next to the vst3sdk folder:
+            set(AAX_SDK_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../../external.avid.aax)
+            if(NOT EXISTS "${AAX_SDK_PATH}/Interfaces/AAX.h")
+                # Check if the AAX SDK is in the vst3sdk folder:
+                set(AAX_SDK_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../external.avid.aax)
+                if(NOT EXISTS "${AAX_SDK_PATH}/Interfaces/AAX.h")
+                    set(AAX_SDK_PATH "")
+                endif()
+            endif()
+            if(NOT "${AAX_SDK_PATH}" STREQUAL "")
+                get_filename_component(AAX_SDK_PATH "${AAX_SDK_PATH}" ABSOLUTE)
+            endif()
+            set(SMTG_AAX_SDK_PATH "${AAX_SDK_PATH}" CACHE PATH "Here you can define where to find the AAX SDK" FORCE)
+        else()
+            set(AAX_SDK_PATH "${SMTG_AAX_SDK_PATH}")
+            if(NOT IS_ABSOLUTE ${AAX_SDK_PATH})
+                get_filename_component(AAX_SDK_PATH "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../${AAX_SDK_PATH}" ABSOLUTE)
+            endif()
+            if(NOT EXISTS "${AAX_SDK_PATH}/Interfaces/AAX.h")
+                message(FATAL_ERROR "[SMTG] SMTG_AAX_SDK_PATH is set but does not point to an expected location!")
+            else()
+                set(SMTG_AAX_SDK_PATH "${AAX_SDK_PATH}" CACHE PATH "Here you can define where to find the AAX SDK" FORCE)
+            endif()
+        endif()
+        if(EXISTS "${SMTG_AAX_SDK_PATH}")
+            message(STATUS "[SMTG] SMTG_AAX_SDK_PATH is set to: " ${SMTG_AAX_SDK_PATH})
+        else()
+            message(STATUS "[SMTG] SMTG_AAX_SDK_PATH is not set. If you need it, please download the AAX SDK!")
+        endif()
+    endif(SMTG_MAC OR SMTG_WIN)
+endfunction(setupAaxSupport)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddAAXLibrary.cmake

@@ -0,0 +1,73 @@
+
+#------------------------------------------------------------------------
+# Includes
+#------------------------------------------------------------------------
+include(SMTG_AddSMTGLibrary)
+
+#------------------------------------------------------------------------
+# Returns the Windows architecture.
+#
+# This name will be used as a folder name inside the Plug-in package.
+# The variable SMTG_WIN_ARCHITECTURE_NAME will be set.
+# @param target The target to which SMTG_WIN_ARCHITECTURE_NAME will be added. 
+function(smtg_target_set_aax_win_architecture_name target)
+    if(${GENERATOR_PLATFORM} MATCHES "win32")
+        set(WIN_ARCHITECTURE_NAME "win32")
+    else()
+        set(WIN_ARCHITECTURE_NAME "x64")    
+    endif()
+
+    set_target_properties(${target}
+        PROPERTIES
+            SMTG_WIN_ARCHITECTURE_NAME ${WIN_ARCHITECTURE_NAME}           
+    )
+endfunction(smtg_target_set_aax_win_architecture_name)
+
+#------------------------------------------------------------------------
+# Adds a AAX target.
+#
+# @param target The target to which a AAX Plug-in will be added. 
+# @param pkg_name name of the created package
+# for example: 
+# smtg_add_aaxplugin_with_pkgname(${target} "A Gain" ${again_sources})
+function(smtg_add_aaxplugin_with_pkgname target pkg_name)
+    add_library(${target} MODULE ${ARGN})
+    smtg_target_set_aax_win_architecture_name(${target})
+    smtg_target_make_plugin_package(${target} ${pkg_name} aaxplugin)
+    # smtg_dump_plugin_package_variables(${target})
+    if(SMTG_MAC AND XCODE)
+        # disable automatic signing for AAX
+        set_target_properties(${target}
+            PROPERTIES
+                XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY ""
+        )
+    endif(SMTG_MAC AND XCODE)
+endfunction(smtg_add_aaxplugin_with_pkgname)
+
+#------------------------------------------------------------------------
+# Adds a AAX target.
+#
+# @param target The target to which a AAX Plug-in will be added.
+# @param PACKAGE_NAME <Name> The name of the package [optional] if not present
+# @param SOURCES_LIST <sources> List of sources to add to target project [mandatory when PACKAGE_NAME is used]
+# for example: 
+# smtg_add_aaxplugin(${target} PACKAGE_NAME "A Gain" SOURCES_LIST ${again_sources})
+# or
+# smtg_add_aaxplugin(${target} ${again_sources})
+function(smtg_add_aaxplugin target)
+    set(oneValueArgs PACKAGE_NAME)
+    set(sourcesArgs SOURCES_LIST)
+    cmake_parse_arguments(PARSE_ARGV 0 PARAMS "${options}" "${oneValueArgs}" "${sourcesArgs}")
+
+    set(SOURCES "${PARAMS_SOURCES_LIST}")
+    if(SOURCES STREQUAL "")
+        set(SOURCES ${ARGN})
+    endif()
+
+    set(pkg_name "${PARAMS_PACKAGE_NAME}")
+    if(pkg_name STREQUAL "")
+        set(pkg_name ${target})
+    endif()
+
+    smtg_add_aaxplugin_with_pkgname(${target} ${pkg_name} ${SOURCES})
+endfunction(smtg_add_aaxplugin)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddCommonOptions.cmake

@@ -0,0 +1,39 @@
+
+#------------------------------------------------------------------------
+# Includes
+#------------------------------------------------------------------------
+include(SMTG_Platform_Windows)
+
+
+# Use by default SMTG_ as prefix for ASSERT,...
+option(SMTG_RENAME_ASSERT "Rename ASSERT to SMTG_ASSERT" ON)
+
+# Logging
+option(SMTG_ENABLE_TARGET_VARS_LOG "Enable Target variables Logging" OFF)
+
+# Create Bundle on Windows for the Plug-ins
+if(SMTG_WIN)
+    option(SMTG_CREATE_BUNDLE_FOR_WINDOWS "Create Bundle on Windows for the Plug-ins (New since VST 3.6.10!)" ON)
+endif(SMTG_WIN)
+
+# Specific Windows Stuff
+# Create Symbolic Link for the Plug-ins
+if(SMTG_WIN)
+    set(DEF_OPT_LINK ON) # be sure to start visual with admin right or adapt the user Group Policy when enabling this
+else()
+    set(DEF_OPT_LINK ON)
+endif(SMTG_WIN)
+option(SMTG_CREATE_PLUGIN_LINK "Create symbolic link for each Plug-in (you need to have the Administrator right on Windows! or change the Local Group Policy to allow create symbolic links)" ${DEF_OPT_LINK})
+
+# Specific Mac Stuff
+if(SMTG_MAC)
+	if(DEFINED SMTG_IOS_DEVELOPMENT_TEAM)
+		set(DEF_OPT_BUILD_IOS ON)
+	else()
+		set(DEF_OPT_BUILD_IOS OFF)
+	endif()
+    option(SMTG_ENABLE_IOS_TARGETS "Enable building iOS targets" ${DEF_OPT_BUILD_IOS})
+
+    set(SMTG_CODE_SIGN_IDENTITY_MAC "Apple Development" CACHE STRING "macOS Code Sign Identity")
+    set(SMTG_CODE_SIGN_IDENTITY_IOS "Apple Development" CACHE STRING "iOS Code Sign Identity")
+endif(SMTG_MAC)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddSMTGLibrary.cmake

@@ -0,0 +1,641 @@
+
+#-------------------------------------------------------------------------------
+# Includes
+#-------------------------------------------------------------------------------
+include(CMakePrintHelpers)
+include(SMTG_UniversalBinary)
+include(SMTG_CodeSign)
+include(SMTG_SetDebugExecutable)
+include(SMTG_AddCommonOptions)
+
+# Customize output location for binaries by setting SMTG_CUSTOM_BINARY_LOCATION via command line
+# cmd: cmake -GXcode -DSMTG_CUSTOM_BINARY_LOCATION="MyPath"
+set(SMTG_CUSTOM_BINARY_LOCATION "" CACHE PATH "Customize output location for binaries")
+
+# define the C++ standard version to use for plugins
+set(SMTG_CXX_STANDARD "" CACHE STRING "C++ standard version used for plugins: 14, 17, 20, 23")
+
+#------------------------------------------------------------------------
+# Returns the windows architecture.
+#
+# This name will be used as a folder name inside the Plug-in package.
+# The variable SMTG_WIN_ARCHITECTURE_NAME will be set.
+function(smtg_target_set_vst_win_architecture_name target)
+    if(SMTG_WIN)
+        if(DEFINED CMAKE_GENERATOR_PLATFORM AND CMAKE_GENERATOR_PLATFORM)
+            string(TOLOWER ${CMAKE_GENERATOR_PLATFORM} GENERATOR_PLATFORM)
+        elseif(DEFINED CMAKE_MODULE_LINKER_FLAGS AND CMAKE_MODULE_LINKER_FLAGS)
+            string(TOLOWER ${CMAKE_MODULE_LINKER_FLAGS} GENERATOR_PLATFORM)
+        endif()
+
+        if(${GENERATOR_PLATFORM} MATCHES "arm64ec")
+            set(WIN_ARCHITECTURE_NAME "arm64ec")
+        elseif(${GENERATOR_PLATFORM} MATCHES "arm64")
+            set(WIN_ARCHITECTURE_NAME "arm64")
+        elseif(${GENERATOR_PLATFORM} MATCHES "arm")
+            set(WIN_ARCHITECTURE_NAME "arm")
+        elseif(${GENERATOR_PLATFORM} MATCHES "win32")
+            set(WIN_ARCHITECTURE_NAME "x86")
+        else()
+            set(WIN_ARCHITECTURE_NAME "x86_64")
+        endif()
+        set(WIN_ARCHITECTURE_NAME ${WIN_ARCHITECTURE_NAME}-win)
+
+        set_target_properties(${target}
+            PROPERTIES
+                SMTG_WIN_ARCHITECTURE_NAME ${WIN_ARCHITECTURE_NAME}
+        )
+    endif(SMTG_WIN)
+endfunction(smtg_target_set_vst_win_architecture_name)
+
+#------------------------------------------------------------------------
+# Prints out all relevant properties of a target for debugging.
+#
+# @param target The target whose properties will be printed.
+function(smtg_target_dump_plugin_package_variables target)
+    cmake_print_properties(
+        TARGETS
+            ${target}
+        PROPERTIES
+            SMTG_PLUGIN_PACKAGE_NAME
+            SMTG_PLUGIN_BINARY_DIR
+            SMTG_PLUGIN_EXTENSION
+            LIBRARY_OUTPUT_DIRECTORY
+            SMTG_PLUGIN_PACKAGE_PATH
+            SMTG_PLUGIN_PACKAGE_CONTENTS
+            SMTG_PLUGIN_PACKAGE_RESOURCES
+            SMTG_PLUGIN_PACKAGE_SNAPSHOTS
+            SMTG_WIN_ARCHITECTURE_NAME
+    )
+endfunction(smtg_target_dump_plugin_package_variables)
+
+#------------------------------------------------------------------------
+# Strips all symbols on linux
+#
+# @param target The target whose build symbols will be stripped
+function(smtg_target_strip_symbols target)
+    add_custom_command(
+        TARGET ${target} POST_BUILD
+        COMMAND ${CMAKE_STRIP} $ENV{CROSS_COMPILE} --strip-debug --strip-unneeded $<TARGET_FILE:${target}>
+    )
+endfunction(smtg_target_strip_symbols)
+
+#------------------------------------------------------------------------
+#! smtg_target_strip_symbols_with_dbg : Strips all symbols on and creates debug file on Linux 
+#
+# @param target The target whose build symbols will be stripped
+function(smtg_target_strip_symbols_with_dbg target)
+    add_custom_command(
+        TARGET ${target} POST_BUILD
+        # Create a target.so.dbg file with debug information
+        COMMAND ${CMAKE_OBJECT_COPY} $ENV{CROSS_COMPILE}objcopy --only-keep-debug $<TARGET_FILE:${target}> $<TARGET_FILE:${target}>.dbg
+        COMMAND ${CMAKE_STRIP} $ENV{CROSS_COMPILE} --strip-debug --strip-unneeded $<TARGET_FILE:${target}>
+        COMMAND ${CMAKE_OBJECT_COPY} $ENV{CROSS_COMPILE}objcopy --add-gnu-debuglink=$<TARGET_FILE:${target}>.dbg $<TARGET_FILE:${target}>
+    )
+endfunction(smtg_target_strip_symbols_with_dbg)
+
+#------------------------------------------------------------------------
+# Creates a symlink to the targets output resp Plug-in.
+#
+# A symlink to the output Plug-in will be created as a post build step.
+#
+# @param target The target whose output is the symlink's source.
+function(smtg_target_create_link_to_plugin target destination)
+    if(${destination} STREQUAL "")
+        message(FATAL_ERROR "[SMTG] no destination defined!")
+    endif()
+
+    get_target_property(PLUGIN_PACKAGE_NAME ${target} SMTG_PLUGIN_PACKAGE_NAME)
+    get_target_property(TARGET_SOURCE       ${target} SMTG_PLUGIN_PACKAGE_PATH)
+    set(TARGET_DESTINATION ${destination})
+
+    if(SMTG_WIN)
+        get_target_property(PLUGIN_BINARY_DIR ${target} SMTG_PLUGIN_BINARY_DIR)
+
+        file(TO_CMAKE_PATH "${TARGET_DESTINATION}/${PLUGIN_PACKAGE_NAME}" SRC_NATIVE_PATH)
+        file(TO_CMAKE_PATH "${PLUGIN_BINARY_DIR}/Debug/${PLUGIN_PACKAGE_NAME}" TARGET_DESTINATION_DEBUG)
+        file(TO_CMAKE_PATH "${PLUGIN_BINARY_DIR}/Release/${PLUGIN_PACKAGE_NAME}" TARGET_DESTINATION_RELEASE)
+
+        add_custom_command(
+            TARGET ${target} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Delete previous link...
+            COMMAND ${CMAKE_COMMAND} -E rm -rf "${SRC_NATIVE_PATH}"
+            COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Creation of the new link...
+            COMMAND ${CMAKE_COMMAND} -E create_symlink
+                "$<$<CONFIG:Debug>:${TARGET_DESTINATION_DEBUG}>"
+                "$<$<CONFIG:Release>:${TARGET_DESTINATION_RELEASE}>"
+                "${SRC_NATIVE_PATH}"
+            COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Finished.
+        )
+    else()
+        set(PLUGIN_TARGET_DESTINATION ${TARGET_DESTINATION}/${PLUGIN_PACKAGE_NAME})
+        add_custom_command(
+            TARGET ${target} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${TARGET_DESTINATION}"
+            COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Delete previous link...
+            COMMAND rm -rf "${PLUGIN_TARGET_DESTINATION}"
+            COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Create new symlink...
+            COMMAND ln -sv "${TARGET_SOURCE}" "${PLUGIN_TARGET_DESTINATION}"
+            COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Finished.
+        )
+    endif(SMTG_WIN)
+endfunction(smtg_target_create_link_to_plugin)
+
+#------------------------------------------------------------------------
+# Customizes folder icon on windows
+#
+# Customizes folder icon on windows by copying desktop.ini and PlugIn.ico into the package.
+#
+# @param target The target whose folder icon will be customized.
+function(smtg_target_add_folder_icon target icon)
+    set(DESKTOP_INI_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../templates/desktop.ini.in)
+    get_target_property(PLUGIN_PACKAGE_PATH ${target} SMTG_PLUGIN_PACKAGE_PATH)
+    add_custom_command(
+        TARGET ${target} POST_BUILD
+        COMMENT "[SMTG] Copy PlugIn.ico and desktop.ini and change their attributes."
+        COMMAND ${CMAKE_COMMAND} -E copy
+            ${icon}
+            ${PLUGIN_PACKAGE_PATH}/PlugIn.ico
+        COMMAND ${CMAKE_COMMAND} -E copy
+            ${DESKTOP_INI_PATH}
+            ${PLUGIN_PACKAGE_PATH}/desktop.ini
+        COMMAND attrib +s ${PLUGIN_PACKAGE_PATH}/desktop.ini
+        COMMAND attrib +s ${PLUGIN_PACKAGE_PATH}/PlugIn.ico
+        COMMAND attrib +s ${PLUGIN_PACKAGE_PATH}
+    )
+endfunction(smtg_target_add_folder_icon)
+
+#------------------------------------------------------------------------
+# Adds the Plug-in's main entry point.
+#
+# The variable public_sdk_SOURCE_DIR needs to be specified.
+#
+# @param target The target to which the main entry point will be added.
+function(smtg_target_add_library_main target)
+    if(public_sdk_SOURCE_DIR)
+        if(SMTG_MAC)
+            target_sources (${target} 
+                PRIVATE 
+                    ${public_sdk_SOURCE_DIR}/source/main/macmain.cpp
+            )
+        elseif(SMTG_WIN)
+            target_sources (${target} 
+                PRIVATE 
+                    ${public_sdk_SOURCE_DIR}/source/main/dllmain.cpp
+            )
+        elseif(SMTG_LINUX)
+            target_sources (${target} 
+                PRIVATE 
+                    ${public_sdk_SOURCE_DIR}/source/main/linuxmain.cpp
+            )
+        endif(SMTG_MAC)
+    endif(public_sdk_SOURCE_DIR)
+endfunction(smtg_target_add_library_main)
+
+#------------------------------------------------------------------------
+# Returns the linux architecture name.
+#
+# This name will be used as a folder name inside the Plug-in package.
+# The variable LINUX_ARCHITECTURE_NAME will be set.
+function(smtg_get_linux_architecture_name)
+    if(ANDROID)
+        set(ARCHITECTURE ${CMAKE_ANDROID_ARCH_ABI})
+        set(LINUX_ARCHITECTURE_NAME ${ARCHITECTURE}-android PARENT_SCOPE)
+    else()
+        # Check if we are cross-compiling for a different architecture
+        if(NOT $ENV{CROSS_COMPILE} STREQUAL "")
+            string(REGEX MATCH "^[A-Z|a-z|0-9|_]*-" CROSS_COMPILE_PREFIX $ENV{CROSS_COMPILE})
+            # Strip trailing - from regex result
+            string(LENGTH ${CROSS_COMPILE_PREFIX} CROSS_COMPILE_PREFIX_LEN)
+            math(EXPR CROSS_COMPILE_PREFIX_LEN "${CROSS_COMPILE_PREFIX_LEN} -1")
+            string(SUBSTRING ${CROSS_COMPILE_PREFIX} 0 ${CROSS_COMPILE_PREFIX_LEN} ARCHITECTURE)
+        else()
+            EXECUTE_PROCESS(
+                COMMAND uname -m
+                COMMAND tr -d '\n'
+                OUTPUT_VARIABLE ARCHITECTURE
+            )
+        endif()
+        set(LINUX_ARCHITECTURE_NAME ${ARCHITECTURE}-linux PARENT_SCOPE)
+    endif(ANDROID)
+endfunction(smtg_get_linux_architecture_name)
+
+#------------------------------------------------------------------------
+# Fatal error if PROJECT_VERSION is not defined
+#
+function(smtg_target_check_project_version target)
+    if(NOT PROJECT_VERSION)
+        # See: https://cmake.org/cmake/help/latest/variable/PROJECT_VERSION.html
+        message(FATAL_ERROR 
+            "[SMTG] PROJECT_VERSION is not defined for target: \"${target}\". "
+            "To fix this, set the VERSION option of the most recent call of "
+            "the cmake project() command e.g. project(myPlugin VERSION 1.0.0)"
+        )
+    endif()
+endfunction()
+
+#------------------------------------------------------------------------
+# Prepare the target to build a Plug-in package.
+#
+# @param target The target whose output will be put into a package.
+# @param extension The package's extension
+function(smtg_target_make_plugin_package target pkg_name extension)
+    smtg_target_check_project_version("${target}")
+    if(${pkg_name} STREQUAL "")
+        set(pkg_name ${target})
+    endif()
+    set(pkg_extension ${extension})
+    if(SMTG_WIN)
+        if(${extension} STREQUAL "bundle")
+            set(extension dll)
+            if(NOT SMTG_CREATE_BUNDLE_FOR_WINDOWS)
+                set(pkg_extension dll)
+            endif(NOT SMTG_CREATE_BUNDLE_FOR_WINDOWS)
+        endif()
+    endif(SMTG_WIN)
+    string(TOUPPER ${extension} PLUGIN_EXTENSION_UPPER)
+
+    if(SMTG_CUSTOM_BINARY_LOCATION)
+        set(SMTG_PLUGIN_BINARY_LOCATION ${SMTG_CUSTOM_BINARY_LOCATION})
+    else()
+        set(SMTG_PLUGIN_BINARY_LOCATION ${CMAKE_BINARY_DIR})
+    endif(SMTG_CUSTOM_BINARY_LOCATION)
+
+    set_target_properties(${target}
+        PROPERTIES
+            LIBRARY_OUTPUT_DIRECTORY        ${SMTG_PLUGIN_BINARY_LOCATION}/${PLUGIN_EXTENSION_UPPER}
+            SMTG_PLUGIN_BINARY_DIR          ${SMTG_PLUGIN_BINARY_LOCATION}/${PLUGIN_EXTENSION_UPPER}
+            SMTG_PLUGIN_EXTENSION           ${extension}
+            SMTG_PLUGIN_PACKAGE_NAME        ${pkg_name}.${pkg_extension}
+            OUTPUT_NAME                     ${pkg_name}
+            SMTG_PLUGIN_PACKAGE_CONTENTS    Contents
+            SMTG_PLUGIN_PACKAGE_RESOURCES   Contents/Resources
+            SMTG_PLUGIN_PACKAGE_SNAPSHOTS   Snapshots
+    )
+
+    get_target_property(PLUGIN_BINARY_DIR   ${target} SMTG_PLUGIN_BINARY_DIR)
+    get_target_property(PLUGIN_EXTENSION    ${target} SMTG_PLUGIN_EXTENSION)
+    get_target_property(PLUGIN_PACKAGE_NAME ${target} SMTG_PLUGIN_PACKAGE_NAME)
+
+    smtg_target_add_library_main(${target})
+    
+    if(SMTG_CXX_STANDARD)
+        target_compile_features(${target}
+            PRIVATE
+                cxx_std_${SMTG_CXX_STANDARD}
+        )
+    endif(SMTG_CXX_STANDARD)
+
+    if(SMTG_MAC)
+        set_target_properties(${target}
+            PROPERTIES
+                BUNDLE TRUE
+        )
+        if(XCODE)
+            set_target_properties(${target}
+                PROPERTIES 
+                    XCODE_ATTRIBUTE_GENERATE_PKGINFO_FILE           YES
+                    XCODE_ATTRIBUTE_WRAPPER_EXTENSION               ${PLUGIN_EXTENSION}
+                    XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS  YES
+                    XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT        $<$<CONFIG:Debug>:dwarf>$<$<CONFIG:Release>:dwarf-with-dsym>
+                    XCODE_ATTRIBUTE_DEPLOYMENT_POSTPROCESSING		$<$<CONFIG:Debug>:NO>$<$<CONFIG:Release>:YES>
+            )
+            if(SMTG_CUSTOM_BINARY_LOCATION)
+              set_target_properties(${target}
+                PROPERTIES 
+                    SMTG_PLUGIN_PACKAGE_PATH    ${PLUGIN_BINARY_DIR}/${PLUGIN_PACKAGE_NAME}
+              )
+            else()
+              set_target_properties(${target}
+                PROPERTIES 
+                    SMTG_PLUGIN_PACKAGE_PATH    ${PLUGIN_BINARY_DIR}/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>/${PLUGIN_PACKAGE_NAME}
+              )
+            endif(SMTG_CUSTOM_BINARY_LOCATION)
+        else()
+            set_target_properties(${target}
+                PROPERTIES 
+                    BUNDLE_EXTENSION            ${PLUGIN_EXTENSION}
+                    LIBRARY_OUTPUT_DIRECTORY    ${PLUGIN_BINARY_DIR}/${CMAKE_BUILD_TYPE}
+                    SMTG_PLUGIN_PACKAGE_PATH    ${PLUGIN_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${PLUGIN_PACKAGE_NAME}
+            )
+        endif(XCODE)
+
+        target_link_libraries(${target}
+            PRIVATE
+                "-framework CoreFoundation"
+        )
+        smtg_target_setup_universal_binary(${target})
+        smtg_target_codesign(${target} ${SMTG_IOS_DEVELOPMENT_TEAM} "${SMTG_CODE_SIGN_IDENTITY_MAC}")
+
+    elseif(SMTG_WIN)
+        if(SMTG_CUSTOM_BINARY_LOCATION)
+            set(PLUGIN_PACKAGE_PATH ${PLUGIN_BINARY_DIR}/${PLUGIN_PACKAGE_NAME})
+        else()
+            set(PLUGIN_PACKAGE_PATH ${PLUGIN_BINARY_DIR}/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>/${PLUGIN_PACKAGE_NAME})
+        endif(SMTG_CUSTOM_BINARY_LOCATION)
+        set_target_properties(${target}
+            PROPERTIES 
+                SUFFIX                      .${PLUGIN_EXTENSION}
+                SMTG_PLUGIN_PACKAGE_PATH    ${PLUGIN_PACKAGE_PATH}
+        )
+        if(MSVC)
+            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+                set_target_properties(${target}
+                    PROPERTIES 
+                        LINK_FLAGS          /EXPORT:GetPluginFactory
+                )
+            endif()
+        endif(MSVC)
+        if(MINGW) # no "lib" prefix for MinGw
+            set_target_properties(${target}
+                PROPERTIES 
+                    PREFIX                  ""
+            )   
+        endif(MINGW)
+        
+        # In order not to have the PDB inside the Plug-in package in release builds, 
+        # we specify a different location (only for MSVC).
+        if(MSVC)
+            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+                set(WIN_PDB WIN_PDB32)
+            else()
+                set(WIN_PDB WIN_PDB64)
+            endif()
+            set_target_properties(${target}
+                PROPERTIES
+                    PDB_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${WIN_PDB}
+            )
+        endif(MSVC)
+
+        # Create Bundle on Windows
+        if(SMTG_CREATE_BUNDLE_FOR_WINDOWS)
+            get_target_property(WIN_ARCHITECTURE_NAME ${target} SMTG_WIN_ARCHITECTURE_NAME)
+
+            # When using LIBRARY_OUTPUT_DIRECTORY, cmake adds another /Debug resp. /Release folder at the end of the path.
+            # In order to prevent cmake from doing that we set LIBRARY_OUTPUT_DIRECTORY_DEBUG and LIBRARY_OUTPUT_DIRECTORY_RELEASE
+            # (or LIBRARY_OUTPUT_DIRECTORY_${CONFIG_UPPERCASE}) directly.
+            get_target_property(PLUGIN_PACKAGE_CONTENTS ${target} SMTG_PLUGIN_PACKAGE_CONTENTS)
+            foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+                string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG_UPPER)
+                if(SMTG_CUSTOM_BINARY_LOCATION)
+                    set_target_properties(${target}
+                        PROPERTIES 
+                            LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${PLUGIN_BINARY_DIR}/${PLUGIN_PACKAGE_NAME}/${PLUGIN_PACKAGE_CONTENTS}/${WIN_ARCHITECTURE_NAME}
+                    )
+                else()
+                    set_target_properties(${target}
+                        PROPERTIES 
+                            LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${PLUGIN_BINARY_DIR}/${OUTPUTCONFIG}/${PLUGIN_PACKAGE_NAME}/${PLUGIN_PACKAGE_CONTENTS}/${WIN_ARCHITECTURE_NAME}
+                    )
+                endif(SMTG_CUSTOM_BINARY_LOCATION)
+            endforeach()
+            if(EXISTS ${SMTG_PACKAGE_ICON_PATH})
+                smtg_target_add_folder_icon(${target} ${SMTG_PACKAGE_ICON_PATH})
+            endif()
+        else()
+            # Do not create a "MyPlugin.vst3/Contents/Resources" folder when SMTG_CREATE_BUNDLE_FOR_WINDOWS is NOT set!
+            set_target_properties(${target}
+                PROPERTIES 
+                    SMTG_DISABLE_CREATE_RESOURCE_FOLDER	1
+            )
+        endif(SMTG_CREATE_BUNDLE_FOR_WINDOWS)
+        # Disable warning LNK4221: "This object file does not define any previously undefined public symbols...".
+        # Enable "Generate Debug Information" in release config by setting "/Zi" and "/DEBUG" flags.
+        if(MSVC)
+            target_compile_options(${target} 
+                PRIVATE 
+                    /wd4221
+                    $<$<CONFIG:RELEASE>:/Zi>
+            )
+            set_property(TARGET ${target} 
+                APPEND PROPERTY 
+                    LINK_FLAGS_RELEASE /DEBUG
+            )
+        endif(MSVC)
+    elseif(SMTG_LINUX)
+        smtg_get_linux_architecture_name() # Sets var LINUX_ARCHITECTURE_NAME
+        message(STATUS "[SMTG] Linux architecture name is ${LINUX_ARCHITECTURE_NAME}.")
+
+        get_target_property(PLUGIN_PACKAGE_CONTENTS ${target} SMTG_PLUGIN_PACKAGE_CONTENTS)
+        set_target_properties(${target}
+            PROPERTIES
+                PREFIX                   ""
+                LIBRARY_OUTPUT_DIRECTORY ${PLUGIN_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${PLUGIN_PACKAGE_NAME}/${PLUGIN_PACKAGE_CONTENTS}/${LINUX_ARCHITECTURE_NAME}
+                SMTG_PLUGIN_PACKAGE_PATH ${PLUGIN_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${PLUGIN_PACKAGE_NAME}
+        )
+
+        # Strip symbols in Release config
+        if(${CMAKE_BUILD_TYPE} MATCHES Release)
+            smtg_target_strip_symbols(${target})
+        elseif(${CMAKE_BUILD_TYPE} MATCHES RelWithDebInfo)
+            smtg_target_strip_symbols_with_dbg(${target})
+        endif()
+    endif(SMTG_MAC)
+
+    smtg_target_create_resources_folder(${target})
+endfunction(smtg_target_make_plugin_package)
+
+#------------------------------------------------------------------------
+# Create "Resources" folder for a target 
+#
+# @param target cmake target
+function(smtg_target_create_resources_folder target)
+    get_target_property(DISABLE_CREATE_RESOURCE_FOLDER ${target} SMTG_DISABLE_CREATE_RESOURCE_FOLDER)
+	if(DEFINED DISABLE_CREATE_RESOURCE_FOLDER AND DISABLE_CREATE_RESOURCE_FOLDER EQUAL 1)
+		return()
+	endif()
+    get_target_property(PLUGIN_PACKAGE_PATH ${target} SMTG_PLUGIN_PACKAGE_PATH)
+    get_target_property(PLUGIN_PACKAGE_RESOURCES ${target} SMTG_PLUGIN_PACKAGE_RESOURCES)
+    set(resources_folder "${PLUGIN_PACKAGE_PATH}/${PLUGIN_PACKAGE_RESOURCES}")
+    add_custom_command(
+            TARGET ${target} PRE_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${resources_folder}"
+    )
+endfunction()
+
+#------------------------------------------------------------------------
+# Adds a resource for a target 
+#
+# The resource which gets copied into the targets Resource Bundle directory.
+#
+# @param target cmake target
+# @param input_file resource file
+# @param ARGV2 destination subfolder inside the Resource folder [optional]
+function(smtg_target_add_plugin_resource target input_file)
+    if(SMTG_LINUX OR (SMTG_WIN AND SMTG_CREATE_BUNDLE_FOR_WINDOWS))
+        get_target_property(PLUGIN_PACKAGE_PATH ${target} SMTG_PLUGIN_PACKAGE_PATH)
+        get_target_property(PLUGIN_PACKAGE_RESOURCES ${target} SMTG_PLUGIN_PACKAGE_RESOURCES)
+
+        set(destination_folder "${PLUGIN_PACKAGE_PATH}/${PLUGIN_PACKAGE_RESOURCES}")
+        set(destination_sourcegroup "${PLUGIN_PACKAGE_RESOURCES}")
+        if(ARGC GREATER 2 AND ARGV2)
+            set(destination_folder "${destination_folder}/${ARGV2}")
+            set(destination_sourcegroup "${destination_sourcegroup}/${ARGV2}")
+        endif()
+
+        # Make the incoming path absolute.
+        get_filename_component(absolute_input_file_path "${input_file}" ABSOLUTE)
+
+        # Extract the filename and its extension
+        get_filename_component(file_name_with_extension "${input_file}" NAME)
+
+        # Create absolute output file path
+        set(absolute_output_file_path "${destination_folder}/${file_name_with_extension}")
+
+        # Add the file as a source to the target inside their corresponding folders
+        source_group("${destination_sourcegroup}" FILES ${input_file})
+        target_sources(${target}
+            PRIVATE
+                ${input_file}
+        )
+        
+        # CMAKE_VS_MSBUILD_COMMAND is not defined when using "-G Ninja" generator but resolves to msbuild.exe when using "-G Visual Studio..."
+        if(CMAKE_VS_MSBUILD_COMMAND)
+            # Hacky workaround: replace all SMTG_PLUGIN_PACKAGE_NAME (e.g. again.vst3) 
+            # occurences by a MSVS macro $(TargetFileName). Using the cmake only approach does not work.
+            get_target_property(PLUGIN_PACKAGE_NAME ${target} SMTG_PLUGIN_PACKAGE_NAME)
+            string(REPLACE "${PLUGIN_PACKAGE_NAME}" "$(TargetFileName)" absolute_output_file_path ${absolute_output_file_path})
+        endif()
+
+        # Create a custom build tool for the specific file
+        add_custom_command(
+            OUTPUT  "${absolute_output_file_path}"
+            MAIN_DEPENDENCY "${absolute_input_file_path}"
+            COMMAND ${CMAKE_COMMAND} 
+                -E copy_if_different
+                    "${absolute_input_file_path}"
+                    "${absolute_output_file_path}"
+            COMMAND ${CMAKE_COMMAND} 
+                -E echo 
+                    "[SMTG] Copied ${absolute_input_file_path} to ${absolute_output_file_path}"
+        )
+    elseif(SMTG_MAC)
+        target_sources(${target}
+            PRIVATE
+                ${input_file}
+        )
+        set(destination_folder "Resources")
+        if(ARGC GREATER 2 AND ARGV2)
+            set(destination_folder "${destination_folder}/${ARGV2}")
+        endif()
+
+        set_source_files_properties(${input_file} 
+            PROPERTIES 
+                MACOSX_PACKAGE_LOCATION "${destination_folder}"
+        )
+    endif(SMTG_LINUX OR (SMTG_WIN AND SMTG_CREATE_BUNDLE_FOR_WINDOWS))
+endfunction(smtg_target_add_plugin_resource)
+
+#------------------------------------------------------------------------
+# Adds multiple snapshots to target.
+#
+# Usage:
+#  smtg_target_add_plugin_snapshots (target
+#    RESOURCES
+#      bitmap0.png
+#      bitmap1.png
+#  )
+# This adds both bitmaps to <Bundle>/Resources/Snapshots
+#
+# @param target The target to which the resources will be added. 
+function(smtg_target_add_plugin_snapshots target)
+    cmake_parse_arguments(
+        PARSED_ARGS # Prefix of output variables e.g. PARSED_ARGS_RESOURCES
+        ""          # List of names for boolean arguments
+        ""          # List of names for mono-valued arguments
+        "RESOURCES" # List of names for multi-valued arguments resp. lists
+        ${ARGN}     # Arguments of the function to parse
+    )
+    get_target_property(PLUGIN_PACKAGE_SNAPSHOTS ${target} SMTG_PLUGIN_PACKAGE_SNAPSHOTS)
+  
+    foreach(rsrc ${PARSED_ARGS_RESOURCES})
+        smtg_target_add_plugin_resource (${target} ${rsrc} ${PLUGIN_PACKAGE_SNAPSHOTS}) 
+    endforeach()
+endfunction(smtg_target_add_plugin_snapshots)
+
+#------------------------------------------------------------------------
+# Adds multiple resources to target.
+#
+# Usage:
+#  smtg_target_add_plugin_resources (target
+#    RESOURCES
+#      bitmap0.png
+#      bitmap1.png
+#    OUTPUT_SUBDIRECTORY
+#      Graphics
+#  )
+# This adds both bitmaps to <Bundle>/Resources/Graphics
+#
+# @param target The target to which the resources will be added. 
+function(smtg_target_add_plugin_resources target)
+    cmake_parse_arguments(
+        PARSED_ARGS # Prefix of output variables e.g. PARSED_ARGS_RESOURCES
+        ""          # List of names for boolean arguments
+        "OUTPUT_SUBDIRECTORY" # List of names for mono-valued arguments
+        "RESOURCES" # List of names for multi-valued arguments resp. lists
+        ${ARGN}     # Arguments of the function to parse
+    )
+
+    foreach(rsrc ${PARSED_ARGS_RESOURCES})
+        smtg_target_add_plugin_resource (${target} ${rsrc} ${PARSED_ARGS_OUTPUT_SUBDIRECTORY}) 
+    endforeach()
+endfunction(smtg_target_add_plugin_resources)
+
+#------------------------------------------------------------------------
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_add_folder_icon target icon)
+    message(DEPRECATION "[SMTG] Use smtg_target_add_folder_icon instead of smtg_add_folder_icon")
+    smtg_target_add_folder_icon (${target} ${icon})
+endfunction(smtg_add_folder_icon)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_create_link_to_plugin target)
+    message(DEPRECATION "[SMTG] Use smtg_target_create_link_to_plugin instead of smtg_create_link_to_plugin")
+    smtg_get_default_plugin_path()
+    smtg_target_create_link_to_plugin(${target} ${SMTG_PLUGIN_TARGET_DEFAULT_PATH})
+endfunction(smtg_create_link_to_plugin)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_make_plugin_package target pkg_name extension)
+    message(DEPRECATION "[SMTG] Use smtg_target_make_plugin_package instead of smtg_make_plugin_package")
+    smtg_target_make_plugin_package (${target} ${pkg_name} ${extension})
+endfunction(smtg_make_plugin_package)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_strip_symbols target)
+    message(DEPRECATION "[SMTG] Use smtg_target_strip_symbols instead of smtg_strip_symbols")
+    smtg_target_strip_symbols (${target})
+endfunction(smtg_strip_symbols)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_add_library_main target)
+    message(DEPRECATION "[SMTG] Use smtg_target_add_library_main instead of smtg_add_library_main")
+    smtg_target_add_library_main (${target})
+endfunction(smtg_add_library_main)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_strip_symbols_with_dbg target)
+    message(DEPRECATION "[SMTG] Use smtg_target_strip_symbols_with_dbg instead of smtg_strip_symbols_with_dbg")
+    smtg_target_strip_symbols_with_dbg (${target})
+endfunction(smtg_strip_symbols_with_dbg)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_dump_plugin_package_variables target)
+    message(DEPRECATION "[SMTG] Use smtg_target_dump_plugin_package_variables instead of smtg_dump_plugin_package_variables")
+    smtg_target_dump_plugin_package_variables (${target})
+endfunction(smtg_dump_plugin_package_variables)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_add_plugin_resource target input_file)
+    message(DEPRECATION "[SMTG] Use smtg_target_add_plugin_resource instead of smtg_add_plugin_resource")
+    smtg_target_add_plugin_resource (${target} ${input_file})
+endfunction(smtg_add_plugin_resource)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_add_plugin_snapshot target snapshot)
+    message(DEPRECATION "[SMTG] Use smtg_target_add_plugin_snapshots instead of smtg_add_plugin_snapshot")
+    smtg_target_add_plugin_snapshots (${target}
+        RESOURCES
+            ${snapshot}
+    )
+endfunction(smtg_add_plugin_snapshot)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddSubDirectories.cmake

@@ -0,0 +1,13 @@
+
+#------------------------------------------------------------------------
+# add every sub directory of the current source dir if it contains a CMakeLists.txt
+function(smtg_add_subdirectories)
+    file(GLOB subDirectories RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *)
+    foreach(dir ${subDirectories})
+        if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${dir}")
+            if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${dir}/CMakeLists.txt")
+                add_subdirectory(${dir})
+            endif()
+        endif()
+    endforeach(dir)
+endfunction(smtg_add_subdirectories)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddVST3AuV2.cmake

@@ -0,0 +1,151 @@
+
+include(SMTG_Bundle)
+include(SMTG_UniversalBinary)
+include(SMTG_CodeSign)
+
+if(XCODE AND SMTG_ENABLE_AUV2_BUILDS)
+
+    set(SMTG_AUV2_FOLDER FOLDER "AudioUnit V2")
+
+    #------------------------------------------------------------------------
+    # Add an AudioUnit Version 2 target for macOS
+    # @param target                 target name
+    # @param BUNDLE_NAME            name of the bundle
+    # @param BUNDLE_IDENTIFIER      bundle identifier
+    # @param INFO_PLIST_TEMPLATE    the info.plist file containing the needed AudioUnit keys
+    # @param VST3_PLUGIN_TARGET     the vst3 plugin target
+    #------------------------------------------------------------------------
+    function(smtg_target_add_auv2 target)
+
+        set(oneValueArgs
+            BUNDLE_NAME
+            BUNDLE_IDENTIFIER
+            INFO_PLIST_TEMPLATE
+            VST3_PLUGIN_TARGET
+        )
+
+        cmake_parse_arguments(ARG "" "${oneValueArgs}" "" ${ARGN})
+
+        if(ARG_UNPARSED_ARGUMENTS)
+            message(FATAL_ERROR "[SMTG] The following parameters are unrecognized: ${ARG_UNPARSED_ARGUMENTS}")
+        endif(ARG_UNPARSED_ARGUMENTS)
+
+        if(ARG_KEYWORDS_MISSING_VALUES)
+            message(FATAL_ERROR "[SMTG] The following parameter values are missing: ${ARG_KEYWORDS_MISSING_VALUES}")
+        endif(ARG_KEYWORDS_MISSING_VALUES)
+
+        foreach(ARG_NAME ${oneValueArgs})
+            set(tmp ARG_${ARG_NAME})
+            if(NOT ${tmp})
+                message(FATAL_ERROR "[SMTG] Missing ${ARG_NAME} argument and value")
+            endif()
+        endforeach()
+
+        string(TIMESTAMP CocoaIdStamp "%Y%j%H%M%S")
+        string(MAKE_C_IDENTIFIER "SMTG_AUCocoaUIBase_${ARG_BUNDLE_NAME}${CocoaIdStamp}" SMTG_AUCocoaUIBase_CLASS_NAME)
+
+        add_library(${target} MODULE 
+            ${public_sdk_SOURCE_DIR}/source/vst/auwrapper/aucocoaview.mm
+            ${public_sdk_SOURCE_DIR}/source/vst/auwrapper/aucocoaview.h
+            ${public_sdk_SOURCE_DIR}/source/vst/auwrapper/auwrapper.mm
+            ${public_sdk_SOURCE_DIR}/source/vst/auwrapper/auwrapper.h
+            ${public_sdk_SOURCE_DIR}/source/vst/auwrapper/NSDataIBStream.mm
+            ${public_sdk_SOURCE_DIR}/source/vst/auwrapper/NSDataIBStream.h
+        )
+
+        smtg_target_setup_universal_binary(${target})
+        smtg_target_codesign(${target} ${SMTG_IOS_DEVELOPMENT_TEAM} "${SMTG_CODE_SIGN_IDENTITY_MAC}")
+      
+        target_compile_features(${target}
+            PUBLIC
+                cxx_std_17
+        )
+
+        target_compile_definitions(${target}
+            PRIVATE
+                SMTG_AUCocoaUIBase_CLASS_NAME=${SMTG_AUCocoaUIBase_CLASS_NAME}
+                CA_USE_AUDIO_PLUGIN_ONLY=0 # TODO: If true will let instruments fail validation
+        )
+
+        target_link_libraries(${target} 
+            PRIVATE 
+                sdk_hosting 
+                "-framework AudioUnit" 
+                "-framework CoreMIDI"
+                "-framework AudioToolbox"
+                "-framework CoreFoundation"
+                "-framework Carbon" 
+                "-framework Cocoa" 
+                "-framework CoreAudio"
+        )
+        if(NOT ${SMTG_COREAUDIO_SDK_PATH} STREQUAL "")
+            target_sources(${target}
+                PRIVATE
+                    "${public_sdk_SOURCE_DIR}/source/vst/auwrapper/ausdk.mm"
+            )
+            target_include_directories(${target}
+                PRIVATE 
+                    "${SMTG_COREAUDIO_SDK_PATH}/**"
+            )
+        elseif(NOT ${SMTG_AUDIOUNIT_SDK_PATH} STREQUAL "")
+            target_compile_definitions(${target}
+                PRIVATE
+                    SMTG_AUWRAPPER_USES_AUSDK
+            )
+## Adding the xcodeproj will crash Xcode when closing and reopening the cmake generated project
+#           target_sources(${target} PRIVATE "${SMTG_AUDIOUNIT_SDK_PATH}/AudioUnitSDK.xcodeproj")
+            target_include_directories(${target}
+                PRIVATE 
+                    "${SMTG_AUDIOUNIT_SDK_PATH}/include/**"
+            )
+            add_custom_command(TARGET ${target}
+                PRE_BUILD
+                COMMAND "xcodebuild" -project "${SMTG_AUDIOUNIT_SDK_PATH}/AudioUnitSDK.xcodeproj" -target AudioUnitSDK build -configuration Release SYMROOT=${CMAKE_BINARY_DIR}/AudioUnitSDK/
+            )
+            target_link_libraries(${target} 
+                PRIVATE 
+                    "${CMAKE_BINARY_DIR}/AudioUnitSDK/Release/libAudioUnitSDK.a"
+            )
+        endif()
+
+        smtg_target_set_bundle(${target}
+            INFOPLIST ${ARG_INFO_PLIST_TEMPLATE}
+            EXTENSION component
+        )
+
+        set(VST3_OUTPUT_DIR ${CMAKE_BINARY_DIR}/VST3)
+        set(outputdir ${VST3_OUTPUT_DIR}/$<CONFIG>)
+        set_target_properties(${target}
+            PROPERTIES
+                XCODE_ATTRIBUTE_GENERATE_PKGINFO_FILE "YES"
+                XCODE_ATTRIBUTE_PRODUCT_NAME "${ARG_BUNDLE_NAME}"
+                XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER ${ARG_BUNDLE_IDENTIFIER}
+                LIBRARY_OUTPUT_DIRECTORY ${VST3_OUTPUT_DIR}
+                ${SMTG_AUV2_FOLDER}
+        )
+
+        add_dependencies(${target} ${ARG_VST3_PLUGIN_TARGET})
+
+        add_custom_command(TARGET ${target} POST_BUILD 
+            COMMAND /bin/mkdir "-p" ${outputdir}/${ARG_BUNDLE_NAME}.component/Contents/Resources
+            COMMAND /bin/rm "-f" "${outputdir}/${ARG_BUNDLE_NAME}.component/Contents/Resources/plugin.vst3"
+            COMMAND /bin/ln "-svfF" "${outputdir}/$<TARGET_FILE_NAME:${ARG_VST3_PLUGIN_TARGET}>.vst3" "${outputdir}/${ARG_BUNDLE_NAME}.component/Contents/Resources/plugin.vst3"
+            COMMAND /bin/rm "-rf" "~/Library/Audio/Plug-Ins/Components/${ARG_BUNDLE_NAME}.component"
+            COMMAND /bin/cp "-rpf" "${outputdir}/${ARG_BUNDLE_NAME}.component" "~/Library/Audio/Plug-Ins/Components/"
+            BYPRODUCTS "~/Library/Audio/Plug-Ins/Components/${ARG_BUNDLE_NAME}.component"
+        )
+        smtg_target_add_custom_codesign_post_build_step(
+            TARGET
+                "${target}"
+            IDENTITY
+                ${SMTG_CODE_SIGN_IDENTITY_MAC}
+            PATH
+                "~/Library/Audio/Plug-Ins/Components/${ARG_BUNDLE_NAME}.component"
+            FLAGS
+            	--timestamp
+        )
+
+    endfunction(smtg_target_add_auv2)
+else()
+    message("[SMTG] * To add an AudioUnit v2 target, you need to use the Xcode generator and set SMTG_COREAUDIO_SDK_PATH to the path of your installation of the CoreAudio SDK!")
+endif(XCODE AND SMTG_ENABLE_AUV2_BUILDS)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddVST3AuV3.cmake

@@ -0,0 +1,227 @@
+
+#------------------------------------------------------------------------
+# Includes
+#------------------------------------------------------------------------
+include(SMTG_CodeSign)
+
+if(SMTG_MAC)
+    if(XCODE)
+        set(SMTG_AUV3_FOLDER FOLDER "AudioUnit V3")
+
+        set(auv3_wrapper_macos_sources
+            ${public_sdk_SOURCE_DIR}/source/vst/auv3wrapper/AUv3WrappermacOS/main.mm
+        )
+
+        set(auv3_wrapper_macosextension_sources
+            ${public_sdk_SOURCE_DIR}/source/vst/auv3wrapper/Shared/AUv3WrapperFactory.mm
+        )
+
+        set(auv3_wrapper_ios_sources
+        )
+
+        set(auv3_wrapper_iosextension_sources
+            ${public_sdk_SOURCE_DIR}/source/vst/auv3wrapper/Shared/AUv3WrapperFactory.mm
+        )
+
+        #------------------------------------------------------------------------
+        # Add a AudioUnit Version 3 App target for macOS
+        # @param target                 target name
+        # @param BuildTarget            must be either "macOS" or "iOS"
+        # @param OutputName             Output App name
+        # @param BundleID               Bundle Identifier
+        # @param AudioUnitConfigHeader  configuration header
+        # @param EntitlementFile        Code sign entitlements file
+        # @param AppSources             Application Sources
+        # @param AppUIResources         Application UI Resources
+        # @param AppInfoPlist           Info.plist for the application
+        # @param ExtensionInfoPlist     Info.plist for the app-extension
+        # @param vst3_plugin_target     the vst3 plugin target
+        #------------------------------------------------------------------------
+        function(smtg_add_auv3_app target BuildTarget OutputName BundleID AudioUnitConfigHeader EntitlementFile AppSources AppUIResources AppInfoPlist ExtensionInfoPlist vst3_plugin_target)
+            if(BuildTarget STREQUAL macOS)
+                set(macOS TRUE)
+            elseif(BuildTarget STREQUAL iOS)
+                set(iOS TRUE)
+            else()
+                message(FATAL_ERROR "[SMTG] BuildTarget must be macOS or iOS not ${BuildTarget}")
+            endif()
+            
+            if(macOS)
+                set(link_frameworks
+                    "-framework Accelerate" 
+                    "-framework AppKit" 
+                    "-framework AudioToolbox" 
+                    "-framework AVFoundation" 
+                    "-framework CoreAudioKit" 
+                    "-framework OpenGL" 
+                    "-framework QuartzCore"
+                    "-framework CoreMIDI"
+                )
+                set(app-extension-target ${target}_appextension_macos)
+                set(app-target ${target})
+                set(app-extension-sources ${auv3_wrapper_macosextension_sources})
+                set(auwrapper-sources ${auv3_wrapper_macos_sources} ${AppSources})
+                set(auwrapper-lib auv3_wrapper_macos)
+            else()
+                set(link_frameworks
+                    "-framework UIKit" 
+                    "-framework CoreAudioKit" 
+                    "-framework AudioToolbox" 
+                    "-framework CoreGraphics" 
+                    "-framework QuartzCore" 
+                    "-framework CoreText" 
+                    "-framework Accelerate" 
+                    "-framework AVFoundation" 
+                    "-framework ImageIO" 
+                    "-framework MobileCoreServices" 
+                    "-framework MediaPlayer"
+                    "-framework CoreMIDI"
+                )
+                set(app-extension-target ${target}_appextension_ios)
+                set(app-target ${target})
+                set(app-extension-sources ${auv3_wrapper_iosextension_sources})
+                set(auwrapper-sources ${AppSources})
+                set(auwrapper-lib auv3_wrapper_ios)
+            endif(macOS)
+
+            set(auwrapper-xib-resources ${AppUIResources})
+
+            get_filename_component(AudioUnitConfig ${AudioUnitConfigHeader} ABSOLUTE)
+            get_filename_component(AppInfoPlist ${AppInfoPlist} ABSOLUTE)
+            get_filename_component(ExtensionInfoPlist ${ExtensionInfoPlist} ABSOLUTE)
+            get_filename_component(EntitlementFile ${EntitlementFile} ABSOLUTE)
+
+            # app-extension
+            add_executable(${app-extension-target} ${app-extension-sources})
+            target_compile_features(${app-extension-target}
+                PUBLIC
+                    cxx_std_17
+            )
+            target_link_libraries(${app-extension-target}
+                PRIVATE
+                    ${auwrapper-lib} 
+                    ${link_frameworks}
+            )
+            add_dependencies(${app-extension-target} "${vst3_plugin_target}")
+            set_target_properties(${app-extension-target}
+                PROPERTIES
+                    # BUNDLE YES
+                    # MACOSX_BUNDLE TRUE
+                    XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER ${BundleID}.appex
+                    XCODE_ATTRIBUTE_INFOPLIST_PREFIX_HEADER ${AudioUnitConfig}
+                    XCODE_ATTRIBUTE_GCC_PREFIX_HEADER ${AudioUnitConfig}
+                    XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES
+                    XCODE_ATTRIBUTE_WRAPPER_EXTENSION appex
+                    XCODE_PRODUCT_TYPE com.apple.product-type.app-extension
+                    ${SMTG_AUV3_FOLDER}
+            )
+            smtg_target_set_bundle(${app-extension-target} INFOPLIST "${ExtensionInfoPlist}" PREPROCESS)
+            
+            # application
+            add_executable(${app-target} ${auwrapper-sources} ${auwrapper-xib-resources})
+            target_compile_features(${app-target}
+                PUBLIC
+                    cxx_std_17
+            )
+            target_link_libraries(${app-target}
+                PRIVATE
+                    ${auwrapper-lib}
+                    ${link_frameworks}
+            )
+            add_dependencies(${app-target} "${app-extension-target}")
+            set_target_properties(${app-target}
+                PROPERTIES
+                    RESOURCE "${auwrapper-xib-resources}"
+                    MACOSX_BUNDLE TRUE
+                    OUTPUT_NAME "${OutputName}"
+                    XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER ${BundleID}
+                    XCODE_ATTRIBUTE_INFOPLIST_PREFIX_HEADER ${AudioUnitConfig}
+                    XCODE_ATTRIBUTE_GCC_PREFIX_HEADER ${AudioUnitConfig}
+                    XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES
+                    ${SMTG_AUV3_FOLDER}
+            )
+            smtg_target_set_bundle(${app-target} INFOPLIST "${AppInfoPlist}" PREPROCESS)
+            get_target_property(PLUGIN_PACKAGE_PATH ${vst3_plugin_target} SMTG_PLUGIN_PACKAGE_PATH)
+
+            if(macOS)
+                add_custom_command(
+                    TARGET ${app-extension-target} POST_BUILD
+                    COMMENT "[SMTG] Copy VST3 plugin into App-Extension"
+                    COMMAND rm -Rf
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/Contents/PlugIns/plugin.vst3"
+                    COMMAND ${CMAKE_COMMAND} -E make_directory
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/Contents/PlugIns/plugin.vst3"
+                    COMMAND /bin/cp -a -v
+                        "${PLUGIN_PACKAGE_PATH}/"
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/Contents/PlugIns/plugin.vst3/"
+                )
+                add_custom_command(
+                    TARGET ${app-target} POST_BUILD
+                    COMMENT "[SMTG] Copy App-Extension into Application"
+                    COMMAND rm -Rf
+                        "$<TARGET_BUNDLE_CONTENT_DIR:${app-target}>/PlugIns/auv3.appex"
+                    COMMAND ${CMAKE_COMMAND} -E make_directory
+                        "$<TARGET_BUNDLE_CONTENT_DIR:${app-target}>/PlugIns/auv3.appex"
+                    COMMAND /bin/cp -a -v
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/"
+                        "$<TARGET_BUNDLE_CONTENT_DIR:${app-target}>/PlugIns/auv3.appex/"
+                )
+                smtg_target_codesign(${app-target} ${SMTG_IOS_DEVELOPMENT_TEAM} "${SMTG_CODE_SIGN_IDENTITY_MAC}")
+                smtg_target_codesign(${app-extension-target} ${SMTG_IOS_DEVELOPMENT_TEAM} "${SMTG_CODE_SIGN_IDENTITY_MAC}")
+                set_target_properties(${app-extension-target}
+                    PROPERTIES
+                        XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS "${EntitlementFile}"
+                )
+            else()
+                add_custom_command(
+                    TARGET ${app-extension-target} POST_BUILD
+                    COMMENT "[SMTG] Copy VST3 plugin into App-Extension"
+                    COMMAND rm -Rf
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/PlugIns/plugin.vst3"
+                    COMMAND ${CMAKE_COMMAND} -E make_directory
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/PlugIns/plugin.vst3"
+                    COMMAND /bin/cp -a -v
+                        "${PLUGIN_PACKAGE_PATH}/"
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/PlugIns/plugin.vst3/"
+                )
+                add_custom_command(
+                    TARGET ${app-target} POST_BUILD
+                    COMMENT "[SMTG] Copy App-Extension into Application"
+                    COMMAND rm -Rf
+                        "$<TARGET_BUNDLE_DIR:${app-target}>/PlugIns/auv3.appex"
+                    COMMAND ${CMAKE_COMMAND} -E make_directory
+                        "$<TARGET_BUNDLE_DIR:${app-target}>/PlugIns/auv3.appex"
+                    COMMAND /bin/cp -a -v
+                        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>/$<TARGET_FILE_NAME:${app-extension-target}>.appex/"
+                        "$<TARGET_BUNDLE_DIR:${app-target}>/PlugIns/auv3.appex/"
+                )
+
+                smtg_target_set_platform_ios(${app-target})
+                smtg_target_set_platform_ios(${app-extension-target})
+                smtg_target_codesign(${app-target} ${SMTG_IOS_DEVELOPMENT_TEAM} "${SMTG_CODE_SIGN_IDENTITY_IOS}")
+                smtg_target_codesign(${app-extension-target} ${SMTG_IOS_DEVELOPMENT_TEAM} "${SMTG_CODE_SIGN_IDENTITY_IOS}")
+
+                set_target_properties(${app-target} 
+                    PROPERTIES 
+                        XCODE_ATTRIBUTE_ENABLE_BITCODE "NO"
+                )
+                set_target_properties(${app-extension-target}
+                    PROPERTIES 
+                        XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS "${EntitlementFile}"
+                        XCODE_ATTRIBUTE_ENABLE_BITCODE "NO"
+                )
+            endif(macOS)
+
+            set(AUV3_APP_TARGET ${app-target} PARENT_SCOPE)
+            set(AUV3_EXTENSION_TARGET ${app-extension-target} PARENT_SCOPE)
+
+        endfunction(smtg_add_auv3_app)      
+
+        # Deprecated since 3.7.4 -----------------------------
+        function(smtg_add_auv3 target BuildTarget OutputName BundleID AudioUnitConfigHeader EntitlementFile AppSources AppUIResources AppInfoPlist ExtensionInfoPlist vst3_plugin_target)
+            message(DEPRECATION "[SMTG] Use smtg_add_auv3_app instead of smtg_add_auv3")
+            smtg_add_auv3_app (${target} ${BuildTarget} ${OutputName} ${BundleID} ${AudioUnitConfigHeader} ${EntitlementFile} ${AppSources} ${AppUIResources} ${AppInfoPlist} ${ExtensionInfoPlist} ${vst3_plugin_target})
+        endfunction(smtg_add_auv3)
+
+    endif(XCODE)
+endif(SMTG_MAC)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddVST3Library.cmake

@@ -0,0 +1,314 @@
+
+#------------------------------------------------------------------------
+# Includes
+#------------------------------------------------------------------------
+include(SMTG_AddSMTGLibrary)
+
+set(SMTG_RUN_VST_VALIDATOR_DEFAULT ON)
+set(SMTG_CREATE_MODULE_INFO_DEFAULT ON)
+
+# Run the Validator after each new compilation of VST3 Plug-ins
+option(SMTG_RUN_VST_VALIDATOR "Run VST validator on VST3 Plug-ins" ${SMTG_RUN_VST_VALIDATOR_DEFAULT})
+
+# Create the moduleinfo.json file after building
+option(SMTG_CREATE_MODULE_INFO "Create the moduleinfo.json file" ${SMTG_CREATE_MODULE_INFO_DEFAULT})
+
+#------------------------------------------------------------------------
+# Runs the validator on a VST3 target.
+#
+# The validator will be run on the target as a post build step.
+#
+# @param target The target which the validator will validate. 
+function(smtg_target_run_vst_validator target)
+    if(TARGET validator)
+        message(STATUS "[SMTG] Setup running validator for ${target}")
+        add_dependencies(${target} validator)
+        if(SMTG_WIN AND NOT SMTG_CREATE_BUNDLE_FOR_WINDOWS)
+            set(TARGET_PATH $<TARGET_FILE:${target}>)
+            add_custom_command(
+                TARGET ${target} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Validator started...
+                COMMAND 
+                    $<TARGET_FILE:validator> 
+                    "${TARGET_PATH}" 
+                    WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+                COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Validator finished.
+            )
+        else()
+            get_target_property(PLUGIN_PACKAGE_PATH ${target} SMTG_PLUGIN_PACKAGE_PATH)
+            add_custom_command(
+                TARGET ${target} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Validator started...
+                COMMAND 
+                    $<TARGET_FILE:validator> 
+                    $<$<CONFIG:Debug>:${PLUGIN_PACKAGE_PATH}>
+                    $<$<CONFIG:Release>:${PLUGIN_PACKAGE_PATH}> 
+                    WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+                COMMAND ${CMAKE_COMMAND} -E echo [SMTG] Validator finished.
+            )
+        endif()
+    endif(TARGET validator)
+endfunction(smtg_target_run_vst_validator)
+
+#------------------------------------------------------------------------
+# Runs the moduleinfotool on a VST3 target.
+#
+# The moduleinfotool will be run on the target as a post build step and
+# generates a moduleinfo.json file inside the VST 3 bundle.
+#
+# @param target The target for which the moduleinfotool will create the file. 
+# @param MODULEINFO_COMPATIBILITY <Path> The path to the compatibility json file [optional]
+function(smtg_target_create_module_info_file target)   
+    set(oneValueArgs MODULEINFO_COMPATIBILITY)
+    cmake_parse_arguments(PARSE_ARGV 1 PARAMS "" "${oneValueArgs}" "")
+   
+    if(NOT SMTG_CREATE_MODULE_INFO)
+        return()
+    endif()
+    if(SMTG_WIN AND NOT SMTG_CREATE_BUNDLE_FOR_WINDOWS)
+        message(WARNING "[SMTG] No moduleinfo.json file for ${target} generated. Consider to enable SMTG_CREATE_BUNDLE_FOR_WINDOWS.")
+        return()
+    endif()
+
+    message(STATUS "[SMTG] Setup running moduleinfotool for ${target}")
+
+    add_dependencies(${target} moduleinfotool)
+
+    get_target_property(PLUGIN_PACKAGE_PATH ${target} SMTG_PLUGIN_PACKAGE_PATH)
+    set(SMTG_MODULEINFO_PATH_INSIDE_BUNDLE Contents/Resources/moduleinfo.json)
+
+    if(DEFINED PARAMS_MODULEINFO_COMPATIBILITY)
+        add_custom_command(
+            TARGET ${target} POST_BUILD
+            COMMAND 
+                $<TARGET_FILE:moduleinfotool> -create -version ${PROJECT_VERSION} 
+                -path "${PLUGIN_PACKAGE_PATH}"
+                -compat "${CMAKE_CURRENT_SOURCE_DIR}/${PARAMS_MODULEINFO_COMPATIBILITY}"
+                -output "${PLUGIN_PACKAGE_PATH}/${SMTG_MODULEINFO_PATH_INSIDE_BUNDLE}"
+                WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+        )
+    else()
+        add_custom_command(
+            TARGET ${target} POST_BUILD
+            COMMAND 
+                $<TARGET_FILE:moduleinfotool> -create -version ${PROJECT_VERSION} 
+                -path "${PLUGIN_PACKAGE_PATH}"
+                -output "${PLUGIN_PACKAGE_PATH}/${SMTG_MODULEINFO_PATH_INSIDE_BUNDLE}"
+                WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+        )
+    endif()
+    if(SMTG_MAC)
+        add_custom_command(
+            TARGET ${target} POST_BUILD
+            COMMAND 
+                codesign -f -s "-" -v "${PLUGIN_PACKAGE_PATH}/${SMTG_MODULEINFO_PATH_INSIDE_BUNDLE}"
+                WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+        )
+    endif()
+endfunction()
+
+#------------------------------------------------------------------------
+# Set SMTG_PLUGIN_TARGET_PATH to default VST3 Path
+function(smtg_get_vst3_path)
+    # here you can define the VST3 Plug-ins folder (it will be created), SMTG_PLUGIN_TARGET_DEFAULT_PATH will be set
+    smtg_get_default_vst3_path()
+
+    set(SMTG_PLUGIN_TARGET_USER_PATH "" CACHE PATH "Here you can redefine the VST3 Plug-ins folder")
+    if(NOT ${SMTG_PLUGIN_TARGET_USER_PATH} STREQUAL "")
+        set(PLUGIN_TARGET_PATH ${SMTG_PLUGIN_TARGET_USER_PATH})
+    else()
+        set(PLUGIN_TARGET_PATH ${SMTG_PLUGIN_TARGET_DEFAULT_PATH})
+    endif()
+    
+    if(NOT ${PLUGIN_TARGET_PATH} STREQUAL "" AND SMTG_CREATE_PLUGIN_LINK)
+        if(NOT EXISTS ${PLUGIN_TARGET_PATH})
+            message(STATUS "[SMTG] Create folder: " ${PLUGIN_TARGET_PATH})
+            if(SMTG_WIN)
+                smtg_create_directory_as_admin_win(${PLUGIN_TARGET_PATH})
+            else()
+                file(MAKE_DIRECTORY ${PLUGIN_TARGET_PATH})
+            endif(SMTG_WIN)
+        endif(NOT EXISTS ${PLUGIN_TARGET_PATH})
+    endif(NOT ${PLUGIN_TARGET_PATH} STREQUAL "" AND SMTG_CREATE_PLUGIN_LINK)
+    if(EXISTS ${PLUGIN_TARGET_PATH})
+        message(STATUS "[SMTG] SMTG_PLUGIN_TARGET_PATH is set to: " ${PLUGIN_TARGET_PATH})
+    else()
+        message(STATUS "[SMTG] SMTG_PLUGIN_TARGET_PATH is not set!")
+    endif(EXISTS ${PLUGIN_TARGET_PATH})
+    set(SMTG_PLUGIN_TARGET_PATH ${PLUGIN_TARGET_PATH} PARENT_SCOPE)
+endfunction(smtg_get_vst3_path)
+
+#------------------------------------------------------------------------
+# Adds a VST3 target.
+#
+# @param target The target to which a VST3 Plug-in will be added.
+# @param pkg_name name of the created package
+# @param MODULEINFO_COMPATIBILITY <path> The path to the compatibility json file [optional]
+function(smtg_add_vst3plugin_with_pkgname target pkg_name)
+    #message(STATUS "[SMTG] target is ${target}")
+    #message(STATUS "[SMTG] pkg_name is ${pkg_name}")
+
+    set(oneValueArgs MODULEINFO_COMPATIBILITY)
+    set(sourcesArgs SOURCES_LIST)
+    cmake_parse_arguments(PARSE_ARGV 2 PARAMS "" "${oneValueArgs}" "${sourcesArgs}")
+
+    #message(STATUS "[SMTG] PARAMS_UNPARSED_ARGUMENTS is ${PARAMS_UNPARSED_ARGUMENTS}")
+    #message(STATUS "[SMTG] PARAMS_MODULEINFO_COMPATIBILITY is ${PARAMS_MODULEINFO_COMPATIBILITY}")
+    #message(STATUS "[SMTG] PARAMS_SOURCES_LIST is ${PARAMS_SOURCES_LIST}")
+
+    if(NOT EXISTS ${SMTG_PACKAGE_ICON_PATH})
+        set(SMTG_PACKAGE_ICON_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../templates/VST_Logo_Steinberg.ico)
+    endif()
+    #message(STATUS "[SMTG] SMTG_PACKAGE_ICON_PATH is ${SMTG_PACKAGE_ICON_PATH}")
+
+    if(DEFINED PARAMS_SOURCES_LIST)
+        set(SOURCES "${PARAMS_SOURCES_LIST}")
+    else()
+        set(SOURCES "${PARAMS_UNPARSED_ARGUMENTS}")
+    endif()
+
+    add_library(${target} MODULE "${SOURCES}")
+  
+    smtg_target_set_vst_win_architecture_name(${target})
+    smtg_target_make_plugin_package(${target} ${pkg_name} vst3)
+
+    ####################
+    # Workaround for Xcode 15 not allowing to add adhoc_codesign linker setting
+    ####################
+    if(SMTG_MAC AND XCODE_VERSION VERSION_GREATER_EQUAL 15)
+	    get_target_property(PLUGIN_PACKAGE_PATH ${target} SMTG_PLUGIN_PACKAGE_PATH)
+        add_custom_command(
+            TARGET ${target} POST_BUILD
+            COMMENT "[SMTG] Adhoc codesign workaround for Xcode 15"
+            COMMAND codesign --force --verbose --sign -
+                "${PLUGIN_PACKAGE_PATH}"
+        )
+	endif()
+    
+    if(SMTG_ENABLE_TARGET_VARS_LOG)
+        smtg_target_dump_plugin_package_variables(${target})
+    endif(SMTG_ENABLE_TARGET_VARS_LOG)
+
+    if(DEFINED PARAMS_MODULEINFO_COMPATIBILITY)
+        smtg_target_create_module_info_file(${target} MODULEINFO_COMPATIBILITY "${PARAMS_MODULEINFO_COMPATIBILITY}")
+    else()
+        smtg_target_create_module_info_file(${target})
+    endif()
+
+    if(SMTG_RUN_VST_VALIDATOR)
+        smtg_target_run_vst_validator(${target})
+    endif(SMTG_RUN_VST_VALIDATOR)
+
+    if(SMTG_CREATE_PLUGIN_LINK)
+        smtg_get_vst3_path()
+        smtg_target_create_link_to_plugin(${target} ${SMTG_PLUGIN_TARGET_PATH})
+    endif(SMTG_CREATE_PLUGIN_LINK)
+
+endfunction(smtg_add_vst3plugin_with_pkgname)
+
+#------------------------------------------------------------------------
+# Adds a VST3 target.
+#
+# @param target The target to which a VST3 Plug-in will be added. 
+# @param PACKAGE_NAME <Name> The name of the package [optional] if not present
+# @param MODULEINFO_COMPATIBILITY <path> The path to the compatibility json file [optional]
+# @param SOURCES_LIST <sources> List of sources to add to target project [mandatory when PACKAGE_NAME is used]
+# for example: 
+# smtg_add_vst3plugin(${target} PACKAGE_NAME "A Gain" SOURCES_LIST ${again_sources})
+# smtg_add_vst3plugin(${target} PACKAGE_NAME "A Gain" MODULEINFO_COMPATIBILITY compat.json SOURCES_LIST ${again_sources})
+# or
+# smtg_add_vst3plugin(${target} ${again_sources})
+function(smtg_add_vst3plugin target)
+    set(oneValueArgs PACKAGE_NAME MODULEINFO_COMPATIBILITY)
+    set(sourcesArgs SOURCES_LIST)
+    cmake_parse_arguments(PARSE_ARGV 1 PARAMS "${options}" "${oneValueArgs}" "${sourcesArgs}")
+
+    #message(STATUS "[SMTG] PARAMS_UNPARSED_ARGUMENTS is ${PARAMS_UNPARSED_ARGUMENTS}")
+    #message(STATUS "[SMTG] PARAMS_PACKAGE_NAME is ${PARAMS_PACKAGE_NAME}")
+    #message(STATUS "[SMTG] PARAMS_SOURCES is ${PARAMS_SOURCES_NAME}")
+    #message(STATUS "[SMTG] PARAMS_MODULEINFO_COMPATIBILITY is ${PARAMS_MODULEINFO_COMPATIBILITY}")
+
+    set(SOURCES "${PARAMS_SOURCES_LIST}")
+    if(SOURCES STREQUAL "")
+        set(SOURCES ${PARAMS_UNPARSED_ARGUMENTS})
+    endif()
+   
+    set(pkg_name "${PARAMS_PACKAGE_NAME}")
+    if(pkg_name STREQUAL "")
+        set(pkg_name ${target})
+    endif()
+
+    #message(STATUS "[SMTG] target is ${target}.")
+    #message(STATUS "[SMTG] pkg_name is ${pkg_name}.")
+    #message(STATUS "[SMTG] SOURCES is ${SOURCES}.")
+
+    if(DEFINED PARAMS_MODULEINFO_COMPATIBILITY)
+        set(SMTG_MODULEINFO_COMPATIBILITY "${PARAMS_MODULEINFO_COMPATIBILITY}")
+        smtg_add_vst3plugin_with_pkgname(${target} ${pkg_name} MODULEINFO_COMPATIBILITY "${SMTG_MODULEINFO_COMPATIBILITY}" SOURCES_LIST ${SOURCES})
+    else()
+        smtg_add_vst3plugin_with_pkgname(${target} ${pkg_name} ${SOURCES})
+    endif()
+endfunction(smtg_add_vst3plugin)
+
+#------------------------------------------------------------------------
+# Adds a VST3 target for iOS
+#
+# @param sign_identity which code signing identity to use
+# @param target The target to which a VST3 Plug-in will be added.
+function(smtg_add_ios_vst3plugin target sign_identity pkg_name)
+    if(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+        add_library(${target} MODULE ${ARGN})
+        set_target_properties(${target}
+            PROPERTIES 
+                XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY  "${SMTG_CODE_SIGN_IDENTITY_IOS}"
+                XCODE_ATTRIBUTE_ENABLE_BITCODE      "NO"
+				SMTG_DISABLE_CREATE_RESOURCE_FOLDER	1
+        )
+		if(SMTG_IOS_DEVELOPMENT_TEAM)
+			set_target_properties(${target}
+				PROPERTIES 
+					XCODE_ATTRIBUTE_DEVELOPMENT_TEAM    ${SMTG_IOS_DEVELOPMENT_TEAM}
+			)
+		endif(SMTG_IOS_DEVELOPMENT_TEAM)
+        smtg_target_make_plugin_package(${target} ${pkg_name} vst3)
+
+        if(SMTG_ENABLE_TARGET_VARS_LOG)
+            smtg_target_dump_plugin_package_variables(${target})
+        endif(SMTG_ENABLE_TARGET_VARS_LOG)
+
+        smtg_target_set_platform_ios(${target})
+        get_target_property(PLUGIN_PACKAGE_PATH ${target} SMTG_PLUGIN_PACKAGE_PATH)
+        add_custom_command(
+            TARGET ${target} POST_BUILD
+            COMMENT "[SMTG] Codesign"            
+            COMMAND codesign --force --verbose --sign "${sign_identity}"
+                "${PLUGIN_PACKAGE_PATH}"
+        )
+
+    endif(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+endfunction(smtg_add_ios_vst3plugin)
+
+#------------------------------------------------------------------------
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_run_vst_validator target)
+    message(DEPRECATION "[SMTG] Use smtg_target_run_vst_validator instead of smtg_run_vst_validator")
+    smtg_target_run_vst_validator (${target})
+endfunction(smtg_run_vst_validator)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_add_vst3_resource target input_file)
+    message(DEPRECATION "[SMTG] Use smtg_target_add_plugin_resources instead of smtg_add_vst3_resource")
+    smtg_target_add_plugin_resources (${target}
+        RESOURCES
+            ${input_file}
+    )
+endfunction(smtg_add_vst3_resource)
+
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_add_vst3_snapshot target snapshot)
+    message(DEPRECATION "[SMTG] Use smtg_target_add_plugin_snapshots instead of smtg_add_vst3_snapshot")
+    smtg_target_add_plugin_snapshots (${target}
+        RESOURCES
+            ${snapshot}
+    )
+endfunction(smtg_add_vst3_snapshot)

engine/vendor/vst3sdk/cmake/modules/SMTG_AddVST3Options.cmake

@@ -0,0 +1,7 @@
+
+#-------------------------------------------------------------------------------
+# Includes
+#-------------------------------------------------------------------------------
+include(SMTG_SetupVST3LibraryDefaultPath)
+include(SMTG_AddCommonOptions)
+

engine/vendor/vst3sdk/cmake/modules/SMTG_Bundle.cmake

@@ -0,0 +1,170 @@
+
+include(CMakeParseArguments)
+
+#[=======================================================================[.md:
+
+    Configures the macOS bundle
+    The usual usage is:
+    ```cmake
+    smtg_target_set_bundle(yourplugin
+        BUNDLE_IDENTIFIER "com.yourcompany.vst3.yourplugin"
+        COMPANY_NAME "yourplugin"
+    )
+    ```
+#]=======================================================================]
+function(smtg_target_set_bundle target)
+    if(NOT SMTG_MAC)
+        return()
+    endif(NOT SMTG_MAC)
+
+    set(options 
+        PREPROCESS
+    )
+    set(oneValueArgs 
+        EXTENSION 
+        INFOPLIST
+        INFOPLIST_IN
+        BUNDLE_IDENTIFIER
+        COMPANY_NAME
+    )
+    set(multiValueArgs 
+        RESOURCES 
+        PREPROCESSOR_FLAGS 
+    )
+    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(ARG_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "[SMTG] The following parameters are unrecognized: ${ARG_UNPARSED_ARGUMENTS}")
+    endif(ARG_UNPARSED_ARGUMENTS)
+
+    # Adding the bundle resources to the target sources creates a warning, see https://cmake.org/Bug/view.php?id=15272
+    target_sources(${target} 
+        PRIVATE
+            ${ARG_RESOURCES}
+    )
+
+    get_target_property(type ${target} TYPE)
+    if(type STREQUAL MODULE_LIBRARY)
+        set_target_properties(${target}
+            PROPERTIES
+                BUNDLE TRUE
+        )
+    elseif(type STREQUAL EXECUTABLE)
+        set_target_properties(${target}
+            PROPERTIES
+                MACOSX_BUNDLE TRUE
+        )
+    endif()
+
+    if(ARG_EXTENSION)
+        if(XCODE)
+            set_target_properties(${target}
+                PROPERTIES
+                    XCODE_ATTRIBUTE_WRAPPER_EXTENSION ${ARG_EXTENSION}
+            )
+        else()
+            set_target_properties(${target}
+                PROPERTIES
+                    BUNDLE_EXTENSION ${ARG_EXTENSION}
+            )
+        endif(XCODE)
+    endif(ARG_EXTENSION)
+
+    if(ARG_RESOURCES)
+        set_source_files_properties(${ARG_RESOURCES}
+            PROPERTIES
+                MACOSX_PACKAGE_LOCATION Resources
+        )
+    endif(ARG_RESOURCES)
+
+    if(ARG_INFOPLIST AND XCODE)
+        set_target_properties(${target}
+            PROPERTIES
+                XCODE_ATTRIBUTE_INFOPLIST_FILE "${ARG_INFOPLIST}"
+        )
+        if(ARG_PREPROCESS)
+            set_target_properties(${target}
+                PROPERTIES
+                    XCODE_ATTRIBUTE_INFOPLIST_PREPROCESS "YES"
+            )
+        endif(ARG_PREPROCESS)
+        if(ARG_PREPROCESSOR_FLAGS)
+            set_target_properties(${target} 
+                PROPERTIES
+                    XCODE_ATTRIBUTE_INFOPLIST_OTHER_PREPROCESSOR_FLAGS "${ARG_PREPROCESSOR_FLAGS}"
+            )
+        endif(ARG_PREPROCESSOR_FLAGS)
+    elseif(XCODE)
+        # Build Copyright string:
+        string(TIMESTAMP BUNDLE_INFO_STRING_YEAR "%Y")
+        set(BUNDLE_COPYRIGHT "© ${BUNDLE_INFO_STRING_YEAR} ${ARG_COMPANY_NAME}.")
+
+        # Check for custom info.plist template:
+        if(ARG_INFOPLIST_IN)
+            # dest Info.plist.in template file in cmake format
+            # see:  https://duckduckgo.com/?q=MACOSX_BUNDLE_INFO_PLIST
+            set(SMTG_BUNDLE_INFO_PLIST "${PROJECT_BINARY_DIR}/smtg_mac/Info.plist.in")
+            # Configure SMTG_BUNDLE_INFO_PLIST to cmake MACOSX_BUNDLE_INFO_PLIST template
+            # Use @VAR@ for variables not defined in MACOSX_BUNDLE_INFO_PLIST
+            configure_file("${ARG_INFOPLIST_IN}" "${SMTG_BUNDLE_INFO_PLIST}" @ONLY)
+
+            set_target_properties(${smtg_target}
+                PROPERTIES
+                    MACOSX_BUNDLE_INFO_PLIST ${SMTG_BUNDLE_INFO_PLIST}
+            )        
+        endif()
+
+        set_target_properties(${target}
+            PROPERTIES
+                MACOSX_BUNDLE_GUI_IDENTIFIER ${ARG_BUNDLE_IDENTIFIER}
+                MACOSX_BUNDLE_COPYRIGHT ${BUNDLE_COPYRIGHT}
+                MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
+                MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION}
+                MACOSX_BUNDLE_LONG_VERSION_STRING ${PROJECT_VERSION}
+                MACOSX_BUNDLE_INFO_STRING ${PROJECT_VERSION}
+        )
+    endif()
+
+    if(ARG_BUNDLE_IDENTIFIER)
+        if(XCODE)
+        	set_target_properties(${target}
+                PROPERTIES
+                    XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "${ARG_BUNDLE_IDENTIFIER}"
+            )
+        endif(XCODE)
+	endif(ARG_BUNDLE_IDENTIFIER)
+endfunction()
+
+#[=======================================================================[.md:
+    Creates the file projectversion.h and adds the directory as an
+    include directory.
+#]=======================================================================]
+function(smtg_target_configure_version_file target)
+
+    set(SMTG_PROJECT_VERSION "")
+
+    if(NOT "${PROJECT_VERSION_MAJOR}" STREQUAL "")
+        string(APPEND SMTG_PROJECT_VERSION "${PROJECT_VERSION_MAJOR}")
+    endif()
+    if(NOT "${PROJECT_VERSION_MINOR}" STREQUAL "")
+        string(APPEND SMTG_PROJECT_VERSION ".${PROJECT_VERSION_MINOR}")
+    endif()
+    if(NOT "${PROJECT_VERSION_PATCH}" STREQUAL "")
+        string(APPEND SMTG_PROJECT_VERSION ".${PROJECT_VERSION_PATCH}")
+    endif()
+
+    configure_file(${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../templates/projectversion.h.in projectversion.h)
+
+    target_include_directories(${target}
+        PUBLIC
+            "${PROJECT_BINARY_DIR}"
+    )
+endfunction()
+
+#[=======================================================================[.md:
+    Deprecated since 3.7.4
+#]=======================================================================]
+function(smtg_set_bundle target)
+    message(DEPRECATION "[SMTG] Use smtg_target_set_bundle instead of smtg_set_bundle")
+    smtg_target_set_bundle (${target})
+endfunction()

engine/vendor/vst3sdk/cmake/modules/SMTG_CodeSign.cmake

@@ -0,0 +1,86 @@
+
+if(XCODE)
+    option(SMTG_DISABLE_CODE_SIGNING "Disable All Code Signing" OFF)
+    set(SMTG_XCODE_OTHER_CODE_SIGNING_FLAGS "--timestamp" CACHE STRING "Other code signing flags [Xcode]")
+    option(SMTG_XCODE_MANUAL_CODE_SIGN_STYLE "Manual Xcode sign style" OFF)
+endif()
+
+#------------------------------------------------------------------------
+function(smtg_target_codesign target)
+    if(XCODE AND (NOT SMTG_DISABLE_CODE_SIGNING))
+        if(ARGC GREATER 2)
+            set(team "${ARGV1}")
+            set(identity "${ARGV2}")
+            message(STATUS "[SMTG] Codesign ${target} with team '${team}' and identity '${identity}'")
+            set(SMTG_CODESIGN_ATTRIBUTES 
+                XCODE_ATTRIBUTE_DEVELOPMENT_TEAM    "${team}"
+                XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY  "${identity}"
+            )
+        else()
+            message(STATUS "[SMTG] Codesign ${target} for local machine only")
+            set(SMTG_CODESIGN_ATTRIBUTES 
+                XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "-"
+            )
+        endif(ARGC GREATER 2)
+        if(SMTG_XCODE_OTHER_CODE_SIGNING_FLAGS)
+            set(SMTG_CODESIGN_ATTRIBUTES 
+                ${SMTG_CODESIGN_ATTRIBUTES}
+                XCODE_ATTRIBUTE_OTHER_CODE_SIGN_FLAGS "${SMTG_XCODE_OTHER_CODE_SIGNING_FLAGS}"
+            )
+        endif()
+        message(DEBUG "[SMTG] Code Sign Attributes: ${SMTG_CODESIGN_ATTRIBUTES}")
+        set_target_properties(${target}
+            PROPERTIES
+                ${SMTG_CODESIGN_ATTRIBUTES}
+        )
+        if(SMTG_XCODE_MANUAL_CODE_SIGN_STYLE)
+            set_target_properties(${target}
+                PROPERTIES
+                    XCODE_ATTRIBUTE_CODE_SIGN_STYLE "Manual"
+            )
+        endif(SMTG_XCODE_MANUAL_CODE_SIGN_STYLE)
+        if(SMTG_MAC AND (XCODE_VERSION VERSION_GREATER_EQUAL 12))
+            # make sure that the executable is signed before cmake post build commands are run as the
+            # Xcode code-sign step is run after the post build commands are run which would prevent
+            # using the target output on system where everything needs to be code-signed.
+            target_link_options(${target}
+                PRIVATE
+                    LINKER:-adhoc_codesign
+            )
+        endif()
+    endif(XCODE AND (NOT SMTG_DISABLE_CODE_SIGNING))
+endfunction(smtg_target_codesign)
+
+#------------------------------------------------------------------------
+function(smtg_target_add_custom_codesign_post_build_step)
+    if(XCODE AND (NOT SMTG_DISABLE_CODE_SIGNING))
+        set(mono_args PATH TARGET IDENTITY)
+        cmake_parse_arguments(PARSE_ARGV 0
+            PARSED_ARGS    # Prefix of output variables e.g. PARSED_ARGS_RESOURCES
+            ""             # List of names for boolean arguments
+            "${mono_args}" # List of names for mono-valued arguments
+            "FLAGS"        # List of names for multi-valued arguments resp. lists
+        )
+        if(NOT PARSED_ARGS_TARGET)
+            message(FATAL_ERROR "Need TARGET argument")
+        endif()
+        if(NOT PARSED_ARGS_PATH)
+            message(FATAL_ERROR "Need PATH argument")
+        endif()
+        if(PARSED_ARGS_IDENTITY)
+            set(identity "${PARSED_ARGS_IDENTITY}")
+        else()
+            set(identity "-")
+        endif()
+        add_custom_command(TARGET ${PARSED_ARGS_TARGET} POST_BUILD 
+            COMMAND /usr/bin/codesign -v -s "${identity}" --force ${PARSED_ARGS_FLAGS} "${PARSED_ARGS_PATH}"
+        )
+    endif()
+endfunction(smtg_target_add_custom_codesign_post_build_step)
+
+#------------------------------------------------------------------------
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_codesign_target target)
+    message(DEPRECATION "[SMTG] Use smtg_target_codesign instead of smtg_codesign_target")
+    smtg_target_codesign (${target})
+endfunction(smtg_codesign_target)

engine/vendor/vst3sdk/cmake/modules/SMTG_ConfigureCmakeGenerator.cmake

@@ -0,0 +1,49 @@
+
+#------------------------------------------------------------------------
+# Specify Output directories
+#
+# XCode is creating the "Debug/Release" folder on its own and does not need to be added.
+macro(smtg_specify_output_directories)
+    if(SMTG_WIN OR (SMTG_MAC AND CMAKE_GENERATOR STREQUAL Xcode))
+        set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
+        set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
+        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+    else ()
+        set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}")
+        set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}")
+        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/${CMAKE_BUILD_TYPE}")
+    endif(SMTG_WIN OR (SMTG_MAC AND CMAKE_GENERATOR STREQUAL Xcode))
+endmacro(smtg_specify_output_directories)
+
+#------------------------------------------------------------------------
+# Specify build types
+#
+# Specifies what build types (configurations) will be available.
+macro(smtg_specify_build_types)
+    set(CMAKE_CONFIGURATION_TYPES "Debug;Release")
+
+    # This variable is only meaningful to single-configuration generators (such as make and Ninja).
+    set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Build type")
+endmacro(smtg_specify_build_types)
+
+#------------------------------------------------------------------------
+# Group predefined cmake projects
+#
+# Put predefined targets like "ALL_BUILD" and "ZERO_CHECK" into a separate folder within the IDE.
+macro(smtg_group_predefined_cmake_projects)
+    set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER Predefined)
+    set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+endmacro(smtg_group_predefined_cmake_projects)
+
+#------------------------------------------------------------------------
+# Configure CMake generator
+macro(smtg_configure_cmake_generator)
+    smtg_specify_output_directories()
+    smtg_specify_build_types()
+    smtg_group_predefined_cmake_projects()
+
+    # Generates a compile_commands.json file containing the exact compiler calls.
+    # (This option is implemented only by Makefile Generators and the Ninja. It 
+    # is ignored on other generators.)
+    set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE STRING "Generate compile commands" FORCE)
+endmacro(smtg_configure_cmake_generator)

engine/vendor/vst3sdk/cmake/modules/SMTG_CoreAudioSupport.cmake

@@ -0,0 +1,82 @@
+
+#------------------------------------------------------------------------
+function(smtg_private_setup_audiounit_sdk)
+	if("${SMTG_AUDIOUNIT_SDK_PATH}" STREQUAL "")
+		# Check if the AudioUnit SDK is next to the vst3sdk folder:
+		set(AUDIOUNIT_SDK_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../../AudioUnitSDK)
+		if(NOT EXISTS "${AUDIOUNIT_SDK_PATH}/AudioUnitSDK.xcodeproj")
+			# Check if the AudioUnit SDK is in the vst3sdk folder:
+			set(AUDIOUNIT_SDK_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../external.apple.audiounitsdk)
+			if(NOT EXISTS "${AUDIOUNIT_SDK_PATH}/AudioUnitSDK.xcodeproj")
+				set(AUDIOUNIT_SDK_PATH "")
+			endif()
+		endif()
+		if(NOT "${AUDIOUNIT_SDK_PATH}" STREQUAL "")
+			get_filename_component(AUDIOUNIT_SDK_PATH "${AUDIOUNIT_SDK_PATH}" ABSOLUTE)
+		endif()
+		set(SMTG_AUDIOUNIT_SDK_PATH "${AUDIOUNIT_SDK_PATH}" CACHE PATH "Path to the AudioUnit SDK" FORCE)
+	elseif(NOT "${SMTG_AUDIOUNIT_SDK_PATH}" STREQUAL "")
+		set(AUDIOUNIT_SDK_PATH "${SMTG_AUDIOUNIT_SDK_PATH}")
+		if(NOT IS_ABSOLUTE ${AUDIOUNIT_SDK_PATH})
+			get_filename_component(AUDIOUNIT_SDK_PATH "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../${AUDIOUNIT_SDK_PATH}" ABSOLUTE)
+		endif()
+		if(NOT EXISTS "${AUDIOUNIT_SDK_PATH}/AudioUnitSDK.xcodeproj")
+			message(FATAL_ERROR "[SMTG] SMTG_AUDIOUNIT_SDK_PATH is set but does not point to an expected location!")
+		else()
+			set(SMTG_AUDIOUNIT_SDK_PATH "${AUDIOUNIT_SDK_PATH}" CACHE PATH "Path to the AudioUnit SDK" FORCE)
+		endif()
+	endif()
+	if(EXISTS "${SMTG_AUDIOUNIT_SDK_PATH}")
+		message(STATUS "[SMTG] SMTG_AUDIOUNIT_SDK_PATH is set to: " ${SMTG_AUDIOUNIT_SDK_PATH})
+		option(SMTG_ENABLE_AUV2_BUILDS "Enable AUv2 Builds" ON)
+	endif()
+endfunction(smtg_private_setup_audiounit_sdk)
+
+#------------------------------------------------------------------------
+function(smtg_private_setup_coreaudio_sdk)
+	if("${SMTG_COREAUDIO_SDK_PATH}" STREQUAL "")
+		# Check if the CoreAudio SDK is next to the vst3sdk folder:
+		set(COREAUDIO_SDK_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../../CoreAudio)
+		if(NOT EXISTS "${COREAUDIO_SDK_PATH}/AudioUnits/AUPublic/AUBase/AUBase.cpp")
+			# Check if the CoreAudio SDK is in the vst3sdk folder:
+			set(COREAUDIO_SDK_PATH ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../external.apple.coreaudio)
+			if(NOT EXISTS "${COREAUDIO_SDK_PATH}/AudioUnits/AUPublic/AUBase/AUBase.cpp")
+				set(COREAUDIO_SDK_PATH "")
+			endif()
+		endif()
+		if(NOT "${COREAUDIO_SDK_PATH}" STREQUAL "")
+			get_filename_component(COREAUDIO_SDK_PATH "${COREAUDIO_SDK_PATH}" ABSOLUTE)
+		endif()
+		set(SMTG_COREAUDIO_SDK_PATH "${COREAUDIO_SDK_PATH}" CACHE PATH "Here you can define where to find the COREAUDIO SDK" FORCE)
+	else()
+		set(COREAUDIO_SDK_PATH "${SMTG_COREAUDIO_SDK_PATH}")
+		if(NOT IS_ABSOLUTE ${COREAUDIO_SDK_PATH})
+			get_filename_component(COREAUDIO_SDK_PATH "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../${COREAUDIO_SDK_PATH}" ABSOLUTE)
+		endif()
+		if(NOT EXISTS "${COREAUDIO_SDK_PATH}/AudioUnits/AUPublic/AUBase/AUBase.cpp")
+			message(FATAL_ERROR "[SMTG] SMTG_COREAUDIO_SDK_PATH is set but does not point to an expected location!")
+		else()
+			set(SMTG_COREAUDIO_SDK_PATH "${COREAUDIO_SDK_PATH}" CACHE PATH "Here you can define where to find the COREAUDIO SDK" FORCE)
+		endif()
+	endif()
+	if(EXISTS "${SMTG_COREAUDIO_SDK_PATH}")
+		message(STATUS "[SMTG] SMTG_COREAUDIO_SDK_PATH is set to: " ${SMTG_COREAUDIO_SDK_PATH})
+		option(SMTG_ENABLE_AUV2_BUILDS "Enable AUv2 Builds" ON)
+	endif()
+
+endfunction(smtg_private_setup_coreaudio_sdk)
+
+#------------------------------------------------------------------------
+function(setupCoreAudioSupport)
+    if(SMTG_MAC AND XCODE)
+        set(SMTG_IOS_DEVELOPMENT_TEAM "" CACHE STRING "Needed for building the InterAppAudio and AUv3 examples for iOS")
+
+		smtg_private_setup_audiounit_sdk()
+		if(NOT SMTG_ENABLE_AUV2_BUILDS)
+			smtg_private_setup_coreaudio_sdk()
+		endif()
+        if("${SMTG_AUDIOUNIT_SDK_PATH}" STREQUAL "" AND "${SMTG_COREAUDIO_SDK_PATH}" STREQUAL "")
+            message(STATUS "[SMTG] Neither SMTG_AUDIOUNIT_SDK_PATH nor SMTG_COREAUDIO_SDK_PATH is set. This is needed to build AudioUnit Version 2 plug-ins.")
+        endif()
+    endif()
+endfunction(setupCoreAudioSupport)

engine/vendor/vst3sdk/cmake/modules/SMTG_CustomModuleTarget.cmake

@@ -0,0 +1,48 @@
+
+# Custom target in order to get all cmake modules into a VST3 project.
+add_custom_target(cmake_modules
+    SOURCES
+        ${CMAKE_CURRENT_LIST_FILE}
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddCommonOptions.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddSMTGLibrary.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddSubDirectories.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_Bundle.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_CodeSign.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_ConfigureCmakeGenerator.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_DetectPlatform.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_ExportedSymbols.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_GenerateSourceGroups.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_Global.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_PlatformIOS.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_PlatformToolset.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_Platform_Windows.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_PrefixHeader.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_SetDebugExecutable.cmake
+        ${CMAKE_CURRENT_LIST_DIR}/SMTG_UniversalBinary.cmake
+)
+if(VST_SDK)
+    add_custom_target(cmake_VST_modules
+        SOURCES
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_AAXSupport.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddAAXLibrary.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddVST3AuV3.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddVST3Library.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddVST3Options.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_CoreAudioSupport.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_ExportedSymbols.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_FindJack.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_SetupVST3LibraryDefaultPath.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_VST3_SDK.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_VstGuiSupport.cmake
+    )
+endif(VST_SDK)
+
+if(SKI_SDK)
+    add_custom_target(cmake_SKI_modules
+        SOURCES
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddComponentLibrary.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_AddComponentOptions.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_SKI_SDK.cmake
+            ${CMAKE_CURRENT_LIST_DIR}/SMTG_SetupComponentLibraryDefaultPath.cmake
+    )
+endif(SKI_SDK)

engine/vendor/vst3sdk/cmake/modules/SMTG_DetectPlatform.cmake

@@ -0,0 +1,62 @@
+
+# Detect the platform which cmake builds for.
+#
+# Needed for check_language(CXX)
+include(CheckLanguage)
+# The detected platform var is stored within the internal cache of cmake in order to make it
+# available globally.
+set(SMTG_PLATFORM_DETECTION_COMMENT "The platform which was detected by SMTG")
+
+#------------------------------------------------------------------------
+# Detect the Platform
+#
+macro(smtg_detect_platform)
+    if(APPLE)
+        set(SMTG_MAC TRUE CACHE INTERNAL ${SMTG_PLATFORM_DETECTION_COMMENT})
+    elseif(UNIX OR ANDROID_PLATFORM)
+        set(SMTG_LINUX TRUE CACHE INTERNAL ${SMTG_PLATFORM_DETECTION_COMMENT})
+    elseif(WIN32)
+        set(SMTG_WIN TRUE CACHE INTERNAL ${SMTG_PLATFORM_DETECTION_COMMENT})
+    endif(APPLE)
+endmacro(smtg_detect_platform)
+
+#------------------------------------------------------------------------
+# Check if c++ compiler is available
+# Handling cmake issue: https://gitlab.kitware.com/cmake/cmake/-/issues/20890
+function(smtg_check_language_cxx)
+    message(STATUS "[SMTG] Check C++ compiler")
+    check_language(CXX)
+    if(NOT CMAKE_CXX_COMPILER)
+        if(SMTG_MAC)
+            execute_process(COMMAND xcode-select -p OUTPUT_VARIABLE _xcode ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+            cmake_path(SET _xcode NORMALIZE "${_xcode}/../..")
+            string(FIND "${_xcode}"  " " _pos)
+            if(_pos GREATER "-1")
+                message(FATAL_ERROR "[SMTG] Spaces in Xcode path are not supported by cmake: \"${_xcode}\"" )
+            endif()
+        endif()
+    endif()
+endfunction()
+
+#------------------------------------------------------------------------
+# Detect the default Xcode Version
+#
+macro(smtg_detect_xcode_version)
+    if(SMTG_MAC)
+        # Check if CXX compiler is available
+        smtg_check_language_cxx()
+        if(NOT DEFINED ENV{XCODE_VERSION})
+            # find out Xcode version if not set by cmake
+            execute_process(COMMAND xcodebuild -version OUTPUT_VARIABLE XCODE_VERSION ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+            string(REGEX MATCH "Xcode [0-9\\.]+" XCODE_VERSION "${XCODE_VERSION}")
+            string(REGEX REPLACE "Xcode ([0-9\\.]+)" "\\1" XCODE_VERSION "${XCODE_VERSION}")
+        endif()
+        if(XCODE_VERSION VERSION_LESS "9")
+            message(FATAL_ERROR "[SMTG] XCode 9 or newer is required")
+        endif()
+        message(STATUS "[SMTG] Building with Xcode version: ${XCODE_VERSION}")
+        if(NOT DEFINED ENV{SDKROOT})
+            execute_process(COMMAND xcrun --sdk macosx --show-sdk-path OUTPUT_VARIABLE CMAKE_OSX_SYSROOT OUTPUT_STRIP_TRAILING_WHITESPACE)
+        endif()
+    endif(SMTG_MAC)
+endmacro(smtg_detect_xcode_version)

engine/vendor/vst3sdk/cmake/modules/SMTG_ExportedSymbols.cmake

@@ -0,0 +1,40 @@
+
+#------------------------------------------------------------------------
+# Setup symbol visibility
+#
+# Puts symbol visibility to default hidden. 
+macro(smtg_setup_symbol_visibility)
+    set(CMAKE_C_VISIBILITY_PRESET hidden)
+    set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+    set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+endmacro(smtg_setup_symbol_visibility)
+
+#------------------------------------------------------------------------
+# Set exported symbols
+#
+# Specifies the exported symbols by file.
+function(smtg_target_set_exported_symbols target exported_symbols_file)
+    if(MSVC)
+        set_target_properties(${target}
+            PROPERTIES
+                LINK_FLAGS "/DEF:\"${exported_symbols_file}\""
+        )
+    elseif(XCODE)
+        set_target_properties(${target}
+            PROPERTIES
+                XCODE_ATTRIBUTE_EXPORTED_SYMBOLS_FILE "${exported_symbols_file}"
+        )
+    elseif(NOT MINGW)
+        set_target_properties(${target}
+            PROPERTIES
+                LINK_FLAGS "-exported_symbols_list \"${exported_symbols_file}\""
+        )
+    endif(MSVC)
+endfunction(smtg_target_set_exported_symbols)
+
+#------------------------------------------------------------------------
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_set_exported_symbols target exported_symbols_file)
+    message(DEPRECATION "[SMTG] Use smtg_target_set_exported_symbols instead of smtg_set_exported_symbols")
+    smtg_target_set_exported_symbols (${target} ${exported_symbols_file})
+endfunction(smtg_set_exported_symbols)

engine/vendor/vst3sdk/cmake/modules/SMTG_FindJack.cmake

@@ -0,0 +1,61 @@
+
+# - Try to find Jack Audio Libraries
+# libjack; libjackserver;
+# Once done this will define
+#  LIBJACK_FOUND - System has libjack.so
+#  LIBJACK_INCLUDE_DIRS - The jack.h include directories
+#  LIBJACK_LIBRARIES - The libraries needed to use jack
+
+# Install jack on Ubuntu: apt-get install libjack-jackd2-dev
+# Add user to audio group: usermod -a -G audio <yourUserName>
+
+# Install jack on Windows: winget install Jackaudio.JACK2
+# Install jack on macOS: brew install jack
+
+#------------------------------------------------------------------------
+
+# Uncomment to see all locations/paths which are searched
+# set(CMAKE_FIND_DEBUG_MODE TRUE)
+
+if(NOT PROJECT_NAME)
+	message(FATAL_ERROR "[SMTG] Only include SMTG_FindJack AFTER the root \"project(...)\" call is done!")
+endif()
+
+find_path(LIBJACK_INCLUDE_DIR
+    NAMES
+        jack/jack.h
+    PATH_SUFFIXES
+		JACK2/include
+)
+
+find_library(LIBJACK_libjack_LIBRARY
+    NAMES
+        libjack64 
+        libjack
+        jack
+    PATH_SUFFIXES
+		JACK2/lib
+)
+
+find_library(LIBJACK_libjackserver_LIBRARY
+    NAMES
+        libjackserver64
+        libjackserver
+        jackserver
+    PATH_SUFFIXES
+		JACK2/lib
+)
+
+# For debugging
+# message(STATUS "LIBJACK_libjackserver_LIBRARY ${LIBJACK_libjackserver_LIBRARY}")
+# message(STATUS "LIBJACK_libjack_LIBRARY ${LIBJACK_libjack_LIBRARY}")
+# message(STATUS "LIBJACK_INCLUDE_DIR ${LIBJACK_INCLUDE_DIR}")
+
+set(LIBJACK_LIBRARIES ${LIBJACK_libjack_LIBRARY} ${LIBJACK_libjackserver_LIBRARY})
+set(LIBJACK_LIBRARY ${LIBJACK_LIBRARIES})
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LIBJACK_FOUND to TRUE
+# if all listed variables are TRUE
+find_package_handle_standard_args(LIBJACK DEFAULT_MSG
+                                  LIBJACK_LIBRARIES LIBJACK_INCLUDE_DIR)

engine/vendor/vst3sdk/cmake/modules/SMTG_GenerateSourceGroups.cmake

@@ -0,0 +1,28 @@
+
+#------------------------------------------------------------------------
+# Generate Source Groups
+#------------------------------------------------------------------------
+
+#------------------------------------------------------------------------
+function(smtg_generate_source_groups root)
+    foreach(source ${ARGN})
+        set(path ${source})
+        string(REGEX REPLACE "${root}/" "" path "${path}")
+        string(REGEX REPLACE "[\\\\/][^\\\\/]*$" "" path "${path}")
+        string(REGEX REPLACE "^[\\\\/]" "" path "${path}")
+        string(REGEX REPLACE "\\.\\.[\\\\/]" "" path "${path}")
+        string(REGEX REPLACE "/" "\\\\\\\\" path "${path}")
+        source_group(${path} FILES ${source})
+    endforeach()
+endfunction(smtg_generate_source_groups)
+
+#------------------------------------------------------------------------
+function(smtg_target_generate_source_groups target)
+	get_target_property(_source_list ${target} SOURCES)
+
+	foreach(_source IN ITEMS ${_source_list})
+		get_filename_component(_source_path "${_source}" PATH)
+		string(REPLACE "/" "\\" _source_path_msvc "${_source_path}")
+		source_group("${_source_path_msvc}" FILES "${_source}")
+	endforeach()
+endfunction(smtg_target_generate_source_groups)

engine/vendor/vst3sdk/cmake/modules/SMTG_Global.cmake

@@ -0,0 +1,41 @@
+
+#------------------------------------------------------------------------
+# Includes
+#------------------------------------------------------------------------
+include(SMTG_DetectPlatform)
+include(SMTG_ConfigureCmakeGenerator)
+include(SMTG_ExportedSymbols)
+
+# Check for in-source build directory.
+#
+# In order not to pollute the source directory, using a separate build directory is mandatory.
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR OR EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
+    message(SEND_ERROR "[SMTG] In-source builds are not allowed. Please create a separate build directory and run 'cmake /path/to/folder [options]' there.")
+    message(FATAL_ERROR "[SMTG] You can remove the file \"CMakeCache.txt\" and directory \"CMakeFiles\" in ${CMAKE_SOURCE_DIR}.")
+endif()
+
+#------------------------------------------------------------------------
+# Global setup functions/macros
+#
+# Call macros/functions which setup the SDK's basics.
+smtg_detect_platform()
+smtg_configure_cmake_generator()
+smtg_detect_xcode_version()
+
+#------------------------------------------------------------------------
+# Enable VST3 SDK
+#
+# This macro should be called from a 3rd party's plug-in CMakeLists.txt file.
+macro(smtg_enable_vst3_sdk)
+    smtg_configure_cmake_generator()
+    smtg_setup_platform_toolset()
+    smtg_setup_symbol_visibility()
+
+    # Needs to bet set for 'smtg_add_library_main' function.
+    if(DEFINED vst3sdk_SOURCE_DIR)
+        set(public_sdk_SOURCE_DIR ${vst3sdk_SOURCE_DIR}/public.sdk)
+    else ()
+        get_target_property(public_sdk_SOURCE_DIR sdk SOURCE_DIR)
+        set(public_sdk_SOURCE_DIR ${public_sdk_SOURCE_DIR}/public.sdk)
+    endif()
+endmacro(smtg_enable_vst3_sdk)

engine/vendor/vst3sdk/cmake/modules/SMTG_PlatformIOS.cmake

@@ -0,0 +1,41 @@
+
+#------------------------------------------------------------------------
+# Platform
+#------------------------------------------------------------------------
+
+#------------------------------------------------------------------------
+function(smtg_target_set_platform_ios target)
+    if(NOT SMTG_MAC)
+        message(FATAL_ERROR "[SMTG] smtg_target_set_platform_ios only works on macOS, use it in an if(SMTG_MAC) block")
+    endif(NOT SMTG_MAC)
+    set_target_properties(${target}
+        PROPERTIES
+            XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET  "12.0"
+            XCODE_ATTRIBUTE_SDKROOT                     "iphoneos"
+            XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY      "1,2"
+            XCODE_ATTRIBUTE_SUPPORTS_MACCATALYST        "NO"
+    )
+endfunction(smtg_target_set_platform_ios)
+
+#------------------------------------------------------------------------
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_set_platform_ios target)
+    message(DEPRECATION "[SMTG] Use smtg_target_set_platform_ios instead of smtg_set_platform_ios")
+    smtg_target_set_platform_ios (${target})
+endfunction(smtg_set_platform_ios)
+
+#------------------------------------------------------------------------
+function(smtg_create_ios_target_from_target target)
+    set(ios_target ${target}_ios)
+    get_target_property(SOURCES_OF_TARGET ${target} SOURCES)
+    add_library(${ios_target}
+        STATIC
+            ${SOURCES_OF_TARGET}
+    )
+    smtg_target_set_platform_ios(${ios_target})
+    target_compile_features(${ios_target}
+        PUBLIC
+            cxx_std_17
+    )
+endfunction()
+

engine/vendor/vst3sdk/cmake/modules/SMTG_PlatformToolset.cmake

@@ -0,0 +1,123 @@
+
+if(SMTG_WIN)
+    option(SMTG_USE_STATIC_CRT "use static CRuntime on Windows (option /MT)" OFF)
+endif(SMTG_WIN)
+
+#------------------------------------------------------------------------
+# setup the platform toolset (compiler options)
+macro(smtg_setup_platform_toolset)
+    # deprecated
+    if(SMTG_RENAME_ASSERT)
+        add_compile_options(-DSMTG_RENAME_ASSERT=1)
+    endif()
+
+    # Add colors to clang output when using Ninja
+    # See: https://github.com/ninja-build/ninja/wiki/FAQ
+    if(UNIX AND CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_GENERATOR STREQUAL "Ninja")
+        add_compile_options(-fcolor-diagnostics)
+    endif()
+
+    #------------
+    option(SMTG_ENABLE_ADDRESS_SANITIZER "Enable Address Sanitizer" OFF)
+
+    if(SMTG_LINUX)
+        if(SMTG_ENABLE_ADDRESS_SANITIZER)
+            set(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES};ASan")
+            add_compile_options($<$<CONFIG:ASan>:-DDEVELOPMENT=1>)
+            add_compile_options($<$<CONFIG:ASan>:-fsanitize=address>)
+            add_compile_options($<$<CONFIG:ASan>:-DVSTGUI_LIVE_EDITING=1>)
+            add_compile_options($<$<CONFIG:ASan>:-g>)
+            add_compile_options($<$<CONFIG:ASan>:-O0>)
+            set(ASAN_LIBRARY asan)
+            link_libraries($<$<CONFIG:ASan>:${ASAN_LIBRARY}>)
+        endif()
+
+        set(common_linker_flags "-Wl,--no-undefined")
+        set(CMAKE_MODULE_LINKER_FLAGS "${common_linker_flags}" CACHE STRING "Module Library Linker Flags")
+        set(CMAKE_SHARED_LINKER_FLAGS "${common_linker_flags}" CACHE STRING "Shared Library Linker Flags")
+    endif(SMTG_LINUX)
+
+    #------------
+    if(UNIX)
+        if(XCODE)
+            set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+            add_compile_options(-Winconsistent-missing-override) # Suggest override when missing 
+            add_compile_options(-Werror=return-type)
+            add_compile_options(-ffast-math -ffp-contract=fast)
+            if(SMTG_ENABLE_ADDRESS_SANITIZER)
+                set(CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER ON)
+                set(CMAKE_XCODE_GENERATE_SCHEME ON)
+            endif(SMTG_ENABLE_ADDRESS_SANITIZER)
+        else()
+            set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
+            if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+                add_compile_options(-Wsuggest-override)     # Suggest override when missing
+            endif()
+            if(SMTG_MAC)
+                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+            else()
+                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-multichar")
+                if(ANDROID)
+                    set(CMAKE_ANDROID_STL_TYPE c++_static)
+                    link_libraries(dl)
+                 else()
+                    link_libraries(stdc++fs pthread dl)
+                endif(ANDROID)
+            endif(SMTG_MAC)
+        endif(XCODE)
+    #------------
+    elseif(SMTG_WIN)
+        if(MINGW)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-multichar")
+            set(common_linker_flags "-Wl,--no-undefined")
+            set(CMAKE_MODULE_LINKER_FLAGS "${common_linker_flags}" CACHE STRING "Module Library Linker Flags")
+            set(CMAKE_SHARED_LINKER_FLAGS "${common_linker_flags}" CACHE STRING "Shared Library Linker Flags")
+        else()
+            add_definitions(-D_UNICODE)
+            add_definitions(-D_CRT_SECURE_NO_WARNINGS)      # Eliminate deprecation warnings for less secure functions (strcpy...)
+            add_compile_options(/W3)                        # Baseline reasonable warnings
+            add_compile_options(/Zc:__cplusplus)            # __cplusplus should denote the c++ standard
+            add_compile_options(/fp:fast)                   # Floating Point Model
+            add_compile_options($<$<CONFIG:Release>:/Oi>)   # Enable Intrinsic Functions (Yes)
+            add_compile_options($<$<CONFIG:Release>:/Ot>)   # Favor Size Or Speed (Favor fast code)
+            add_compile_options($<$<CONFIG:Release>:/GF>)   # Enable String Pooling
+            add_compile_options($<$<CONFIG:Release>:/EHa>)  # Enable C++ Exceptions
+            add_compile_options($<$<CONFIG:Release>:/Oy>)   # Omit Frame Pointers
+            #add_compile_options($<$<CONFIG:Release>:/Ox>)  # Optimization (/O2: Maximise Speed /0x: Full Optimization)
+            add_compile_options(/MP)                        # Multi-processor Compilation
+            add_compile_options(/wd6031)                    # Return value ignored
+            add_compile_options(/wd6308)                    # Realloc may return null pointer
+            add_compile_options(/wd6330)                    # Incorrect type passed as parameter in call to function
+            add_compile_options(/wd6385)                    # Invalid data
+            add_compile_options(/wd6386)                    # Buffer overrun
+            add_compile_options(/wd28125)                   # The function must be called from within a try/except block
+            add_compile_options(/wd28251)                   # Inconsistent annotation for function
+            #add_definitions("/analyze")                     # Enable Code Analyze
+
+            set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
+            set(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
+            if(DEFINED CMAKE_GENERATOR_PLATFORM AND CMAKE_GENERATOR_PLATFORM)
+                string(TOLOWER ${CMAKE_GENERATOR_PLATFORM} GENERATOR_PLATFORM)
+            endif()
+            if(${GENERATOR_PLATFORM} MATCHES "arm*")
+                add_compile_options($<$<CONFIG:Debug>:/Zi>)     # Program Database
+                add_compile_options($<$<CONFIG:Debug>:/EHsc>)   # Enable C++ Exceptions
+                add_compile_options(/wd4103)                    # Alignment changed after including header
+            else()
+                if(SMTG_ENABLE_ADDRESS_SANITIZER)
+                    add_compile_options($<$<CONFIG:Debug>:/fsanitize=address>) # Enable Address Sanitizer
+                    add_link_options($<$<CONFIG:Debug>:/INCREMENTAL:NO>) # Enable Incremental Linking
+                else()
+                    add_compile_options($<$<CONFIG:Debug>:/ZI>)  # Program Database for Edit And Continue
+                endif()
+            endif()
+            if(SMTG_USE_STATIC_CRT)
+                add_compile_options($<$<CONFIG:Debug>:/MTd>)    # Runtime Library: /MTd = MultiThreaded Debug Runtime
+                add_compile_options($<$<CONFIG:Release>:/MT>)   # Runtime Library: /MT  = MultiThreaded Runtime
+            else()
+                add_compile_options($<$<CONFIG:Debug>:/MDd>)    # Runtime Library: /MDd = MultiThreadedDLL Debug Runtime
+                add_compile_options($<$<CONFIG:Release>:/MD>)   # Runtime Library: /MD  = MultiThreadedDLL Runtime
+            endif(SMTG_USE_STATIC_CRT)
+        endif(MINGW)
+    endif(UNIX)
+endmacro(smtg_setup_platform_toolset)

engine/vendor/vst3sdk/cmake/modules/SMTG_Platform_Windows.cmake

@@ -0,0 +1,34 @@
+
+#------------------------------------------------------------------------
+# Create a given Directory with Admin permission on Windows
+function(smtg_create_directory_as_admin_win directory_name)
+    if(NOT SMTG_WIN)
+        message(FATAL_ERROR "[SMTG] smtg_create_directory_as_admin only works on Windows, use it in an if(SMTG_WIN) block")
+    endif()
+    if(EXISTS ${directory_name})
+        return()
+    endif()
+    set(TMPDIR "$ENV{TEMP}")
+    if(NOT EXISTS ${TMPDIR})
+        set(TMPDIR "$ENV{TMPDIR}")
+    endif()
+    message(STATUS "[SMTG] TMPDIR is set to: " ${TMPDIR})
+    if(NOT EXISTS ${TMPDIR})
+        message(FATAL_ERROR "[SMTG] smtg_create_directory_as_admin does find TEMP Folder!")
+    endif()
+
+    # create the bat creating the Directory
+    set(TMPFILE ${TMPDIR}\\smtg_mkdir_windows_as_admin.bat)
+    file(WRITE ${TMPFILE} "md \"${directory_name}\"")
+
+    execute_process(
+        COMMAND
+            msg * /time:60 /w VST 3 SDK: In order to create the subDirectory:\n\"${directory_name}\"\nyou will need to provide Administrator permission!
+    )
+    # execute with powershell the bat file
+    set(RUNAS "-Verb runAs") 
+    execute_process(
+        COMMAND
+            powershell.exe Start-Process ${TMPFILE} ${RUNAS}
+    )
+endfunction(smtg_create_directory_as_admin_win)

engine/vendor/vst3sdk/cmake/modules/SMTG_PrefixHeader.cmake

@@ -0,0 +1,21 @@
+
+#------------------------------------------------------------------------
+# Prefix Header
+#------------------------------------------------------------------------
+
+#------------------------------------------------------------------------
+function(smtg_target_set_prefix_header target header precompile)
+    if(MSVC)
+    elseif(XCODE)
+        set_target_properties(${target}
+            PROPERTIES
+                XCODE_ATTRIBUTE_GCC_PREFIX_HEADER               "${header}"
+                XCODE_ATTRIBUTE_GCC_PRECOMPILE_PREFIX_HEADER    "${precompile}"
+        )
+    else()
+        target_compile_options(${target}
+            PRIVATE
+                -include "${header}"
+        )
+    endif(MSVC)
+endfunction(smtg_target_set_prefix_header)

engine/vendor/vst3sdk/cmake/modules/SMTG_SetDebugExecutable.cmake

@@ -0,0 +1,37 @@
+
+#------------------------------------------------------------------------
+function(smtg_target_set_debug_executable target executable)
+    if(CMAKE_GENERATOR STREQUAL Xcode)
+        set_target_properties(${target}
+            PROPERTIES
+                XCODE_GENERATE_SCHEME       YES
+                XCODE_SCHEME_EXECUTABLE     "${executable}"
+        )
+        if(ARGC GREATER 2 AND ARGV2)
+            set_target_properties(${target}
+                PROPERTIES
+                    XCODE_SCHEME_ARGUMENTS  "${ARGV2}"
+            )
+        endif()
+    endif()
+
+    if(MSVC)
+        set_target_properties(${target}
+            PROPERTIES
+                VS_DEBUGGER_COMMAND         "${executable}"
+        )
+        if(ARGC GREATER 2 AND ARGV2)
+            set_target_properties(${target}
+                PROPERTIES
+                    VS_DEBUGGER_COMMAND_ARGUMENTS "${ARGV2}"
+            ) 
+        endif()
+    endif(MSVC)
+endfunction(smtg_target_set_debug_executable)
+
+#------------------------------------------------------------------------
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_set_debug_executable target executable)
+    message(DEPRECATION "[SMTG] Use smtg_target_set_debug_executable instead of smtg_set_debug_executable")
+    smtg_target_set_debug_executable (${target} ${executable})
+endfunction(smtg_set_debug_executable)

engine/vendor/vst3sdk/cmake/modules/SMTG_SetupVST3LibraryDefaultPath.cmake

@@ -0,0 +1,50 @@
+
+if(SMTG_WIN)
+    option(SMTG_PLUGIN_TARGET_USER_PROGRAM_FILES_COMMON "use FOLDERID_UserProgramFilesCommon as VST3 target path" ON)
+endif(SMTG_WIN)
+
+#------------------------------------------------------------------------
+# VST3 Folder (following the specification)
+function(smtg_get_default_vst3_path)
+    if(SMTG_WIN)
+        set(win64Found "1")
+        if(NOT ${CMAKE_GENERATOR_PLATFORM} STREQUAL "")
+            string(FIND ${CMAKE_GENERATOR_PLATFORM} x64 win64Found)
+            if(${win64Found} EQUAL -1)
+                string(FIND ${CMAKE_GENERATOR_PLATFORM} ARM64 win64Found)
+            endif()
+        elseif(${CMAKE_GENERATOR} STREQUAL "Visual Studio 15 2017" OR 
+               ${CMAKE_GENERATOR} STREQUAL "Visual Studio 14 2015" OR 
+               ${CMAKE_GENERATOR} STREQUAL "Visual Studio 12 2013" OR 
+               ${CMAKE_GENERATOR} STREQUAL "Visual Studio 11 2012" OR 
+               ${CMAKE_GENERATOR} STREQUAL "Visual Studio 10 2010" OR 
+               ${CMAKE_GENERATOR} STREQUAL "Visual Studio 9 2008")
+                    set(win64Found "-1")
+        else()
+            string(FIND ${CMAKE_GENERATOR} Win32 win32Found)
+            if(NOT ${win32Found} EQUAL -1)
+                set(win64Found "-1")
+            endif()
+        endif()
+        if(${win64Found} EQUAL -1) # for 32bits OS
+            if(EXISTS "$ENV{PROGRAMFILES} (x86)")
+                set(SMTG_PLUGIN_TARGET_DEFAULT_PATH "$ENV{PROGRAMFILES} (x86)\\Common Files\\VST3" PARENT_SCOPE)
+            else()
+                set(SMTG_PLUGIN_TARGET_DEFAULT_PATH "$ENV{PROGRAMFILES}\\Common Files\\VST3" PARENT_SCOPE)
+            endif()
+        else()  # for 64bits OS
+            #FOLDERID_UserProgramFilesCommon
+            if(SMTG_PLUGIN_TARGET_USER_PROGRAM_FILES_COMMON)
+                set(SMTG_PLUGIN_TARGET_DEFAULT_PATH "$ENV{LOCALAPPDATA}\\Programs\\Common\\VST3" PARENT_SCOPE)
+            else()
+                set(SMTG_PLUGIN_TARGET_DEFAULT_PATH "$ENV{CommonProgramW6432}\\VST3" PARENT_SCOPE)
+            endif(SMTG_PLUGIN_TARGET_USER_PROGRAM_FILES_COMMON)
+        endif()
+    elseif(SMTG_MAC)
+        set(SMTG_PLUGIN_TARGET_DEFAULT_PATH "$ENV{HOME}/Library/Audio/Plug-Ins/VST3" PARENT_SCOPE)
+    elseif(SMTG_LINUX)
+        set(SMTG_PLUGIN_TARGET_DEFAULT_PATH "$ENV{HOME}/.vst3" PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "[SMTG] unknown platform")
+    endif(SMTG_WIN)
+endfunction(smtg_get_default_vst3_path)

engine/vendor/vst3sdk/cmake/modules/SMTG_UniversalBinary.cmake

@@ -0,0 +1,45 @@
+
+if(SMTG_MAC)
+    if(XCODE_VERSION VERSION_GREATER_EQUAL 12)
+        option(SMTG_BUILD_UNIVERSAL_BINARY "Build universal binary (x86_64 & arm64)" ON)
+    elseif(XCODE_VERSION VERSION_LESS 10)
+        option(SMTG_BUILD_UNIVERSAL_BINARY "Build universal binary (32 & 64 bit)" OFF)
+    else()
+        # Xcode 10 and 11 can only build x86_64 for macOS
+        set(SMTG_BUILD_UNIVERSAL_BINARY 0)
+    endif()
+endif(SMTG_MAC)
+
+#------------------------------------------------------------------------
+# smtg_target_setup_universal_binary
+#------------------------------------------------------------------------
+function(smtg_target_setup_universal_binary target)
+    if(SMTG_MAC)
+        if(SMTG_BUILD_UNIVERSAL_BINARY)
+            if(XCODE_VERSION VERSION_GREATER_EQUAL 12)
+                set_target_properties(${target}
+                    PROPERTIES
+                        XCODE_ATTRIBUTE_OSX_ARCHITECTURES   "x86_64;arm64;arm64e"
+                        XCODE_ATTRIBUTE_ARCHS               "$(ARCHS_STANDARD_64_BIT)"
+                )
+            else()
+                set_target_properties(${target}
+                    PROPERTIES
+                        XCODE_ATTRIBUTE_OSX_ARCHITECTURES   "x86_64;i386"
+                        XCODE_ATTRIBUTE_ARCHS               "$(ARCHS_STANDARD_32_64_BIT)"
+                )
+            endif()
+            set_target_properties(${target}
+                PROPERTIES
+                    XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH        "$<$<CONFIG:Debug>:YES>$<$<CONFIG:Release>:NO>"
+            )
+        endif(SMTG_BUILD_UNIVERSAL_BINARY)
+    endif(SMTG_MAC)
+endfunction(smtg_target_setup_universal_binary)
+
+#------------------------------------------------------------------------
+# Deprecated since 3.7.4 -----------------------------
+function(smtg_setup_universal_binary target)
+    message(DEPRECATION "[SMTG] Use smtg_target_setup_universal_binary instead of smtg_setup_universal_binary")
+    smtg_target_setup_universal_binary (${target})
+endfunction(smtg_setup_universal_binary)

engine/vendor/vst3sdk/cmake/modules/SMTG_VST3_SDK.cmake

@@ -0,0 +1,394 @@
+
+#------------------------------------------------------------------------
+# Includes
+#------------------------------------------------------------------------
+include(SMTG_Global)
+include(SMTG_AddVST3Library)
+include(SMTG_Bundle)
+include(SMTG_ExportedSymbols)
+include(SMTG_PrefixHeader)
+include(SMTG_PlatformIOS)
+include(SMTG_PlatformToolset)
+include(SMTG_CoreAudioSupport)
+include(SMTG_AAXSupport)
+include(SMTG_VstGuiSupport)
+include(SMTG_UniversalBinary)
+include(SMTG_AddVST3Options)
+
+#------------------------------------------------------------------------
+function(smtg_create_lib_base_target)
+
+    add_library(base
+        STATIC
+            ${SDK_ROOT}/base/source/baseiids.cpp
+            ${SDK_ROOT}/base/source/classfactoryhelpers.h
+            ${SDK_ROOT}/base/source/fbuffer.cpp
+            ${SDK_ROOT}/base/source/fbuffer.h
+            ${SDK_ROOT}/base/source/fcleanup.h
+            ${SDK_ROOT}/base/source/fcommandline.h
+            ${SDK_ROOT}/base/source/fdebug.cpp
+            ${SDK_ROOT}/base/source/fdebug.h
+            ${SDK_ROOT}/base/source/fdynlib.cpp
+            ${SDK_ROOT}/base/source/fdynlib.h
+            ${SDK_ROOT}/base/source/fobject.cpp
+            ${SDK_ROOT}/base/source/fobject.h
+            ${SDK_ROOT}/base/source/fstreamer.cpp
+            ${SDK_ROOT}/base/source/fstreamer.h
+            ${SDK_ROOT}/base/source/fstring.cpp
+            ${SDK_ROOT}/base/source/fstring.h
+            ${SDK_ROOT}/base/source/timer.cpp
+            ${SDK_ROOT}/base/source/timer.h
+            ${SDK_ROOT}/base/source/updatehandler.cpp
+            ${SDK_ROOT}/base/source/updatehandler.h
+            ${SDK_ROOT}/base/thread/include/fcondition.h
+            ${SDK_ROOT}/base/thread/include/flock.h
+            ${SDK_ROOT}/base/thread/source/fcondition.cpp
+            ${SDK_ROOT}/base/thread/source/flock.cpp
+    )
+
+    target_include_directories(base
+        PUBLIC
+            ${SDK_ROOT}
+    )
+
+    # Compiler switches are PUBLIC and will be populated.
+    target_compile_options(base 
+        PUBLIC
+            "$<$<CONFIG:Debug>:-DDEVELOPMENT=1>"
+            "$<$<CONFIG:Release>:-DRELEASE=1>"
+            "$<$<CONFIG:RelWithDebInfo>:-DRELEASE=1>"
+    )
+    
+    target_compile_features(base
+        PUBLIC
+            cxx_std_17
+    )
+    
+    if(MSVC)
+        set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /IGNORE:4221")
+    endif(MSVC)
+    
+    smtg_target_setup_universal_binary(base)
+    
+    # iOS target
+    if(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+        smtg_create_ios_target_from_target(base)
+        set_target_properties(base_ios
+            PROPERTIES
+                ${SDK_IDE_LIBS_FOLDER}
+        )
+        # Compiler switches are PUBLIC and will be populated.
+        target_compile_options(base_ios 
+            PUBLIC
+                "$<$<CONFIG:Debug>:-DDEVELOPMENT=1>"
+                "$<$<CONFIG:Release>:-DRELEASE=1>"
+                "$<$<CONFIG:RelWithDebInfo>:-DRELEASE=1>"
+        )
+    endif(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+
+endfunction()
+
+#------------------------------------------------------------------------
+function(smtg_create_pluginterfaces_target)
+
+    add_library(pluginterfaces
+        STATIC
+            ${SDK_ROOT}/pluginterfaces/base/conststringtable.cpp
+            ${SDK_ROOT}/pluginterfaces/base/conststringtable.h
+            ${SDK_ROOT}/pluginterfaces/base/coreiids.cpp
+            ${SDK_ROOT}/pluginterfaces/base/falignpop.h
+            ${SDK_ROOT}/pluginterfaces/base/falignpush.h
+            ${SDK_ROOT}/pluginterfaces/base/fplatform.h
+            ${SDK_ROOT}/pluginterfaces/base/fstrdefs.h
+            ${SDK_ROOT}/pluginterfaces/base/ftypes.h
+            ${SDK_ROOT}/pluginterfaces/base/funknown.cpp
+            ${SDK_ROOT}/pluginterfaces/base/funknown.h
+            ${SDK_ROOT}/pluginterfaces/base/funknownimpl.h
+            ${SDK_ROOT}/pluginterfaces/base/futils.h
+            ${SDK_ROOT}/pluginterfaces/base/fvariant.h
+            ${SDK_ROOT}/pluginterfaces/base/geoconstants.h
+            ${SDK_ROOT}/pluginterfaces/base/ibstream.h
+            ${SDK_ROOT}/pluginterfaces/base/icloneable.h
+            ${SDK_ROOT}/pluginterfaces/base/ierrorcontext.h
+            ${SDK_ROOT}/pluginterfaces/base/ipersistent.h
+            ${SDK_ROOT}/pluginterfaces/base/ipluginbase.h
+            ${SDK_ROOT}/pluginterfaces/base/istringresult.h
+            ${SDK_ROOT}/pluginterfaces/base/iupdatehandler.h
+            ${SDK_ROOT}/pluginterfaces/base/keycodes.h
+            ${SDK_ROOT}/pluginterfaces/base/pluginbasefwd.h
+            ${SDK_ROOT}/pluginterfaces/base/smartpointer.h
+            ${SDK_ROOT}/pluginterfaces/base/typesizecheck.h
+            ${SDK_ROOT}/pluginterfaces/base/ucolorspec.h
+            ${SDK_ROOT}/pluginterfaces/base/ustring.cpp
+            ${SDK_ROOT}/pluginterfaces/base/ustring.h
+            ${SDK_ROOT}/pluginterfaces/gui/iplugview.h
+            ${SDK_ROOT}/pluginterfaces/gui/iplugviewcontentscalesupport.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstattributes.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstaudioprocessor.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstautomationstate.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstchannelcontextinfo.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstcomponent.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstcontextmenu.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivsteditcontroller.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstevents.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstdataexchange.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivsthostapplication.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstinterappaudio.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstmessage.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstmidicontrollers.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstmidilearn.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstnoteexpression.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstparameterchanges.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstparameterfunctionname.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstphysicalui.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstpluginterfacesupport.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstplugview.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstprefetchablesupport.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstprocesscontext.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstremapparamid.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstrepresentation.h
+            ${SDK_ROOT}/pluginterfaces/vst/ivstunits.h
+            ${SDK_ROOT}/pluginterfaces/vst/vstpresetkeys.h
+            ${SDK_ROOT}/pluginterfaces/vst/vstpshpack4.h
+            ${SDK_ROOT}/pluginterfaces/vst/vstspeaker.h
+            ${SDK_ROOT}/pluginterfaces/vst/vsttypes.h
+    )
+    
+    # check for C11 atomic header
+    include(CheckSourceCompiles)
+    set(SMTG_CHECK_STDATOMIC_H_SRC
+    "#include <stdatomic.h>
+    int main () { 
+        atomic_int_least32_t value = 0;
+        atomic_fetch_add (&value, 1); 
+        return 0; 
+    }"
+    )
+    #set(CMAKE_REQUIRED_QUIET 1)
+    check_source_compiles(CXX "${SMTG_CHECK_STDATOMIC_H_SRC}" SMTG_USE_STDATOMIC_H)
+    if(SMTG_USE_STDATOMIC_H)
+        target_compile_definitions(pluginterfaces
+            PRIVATE
+                "SMTG_USE_STDATOMIC_H=${SMTG_USE_STDATOMIC_H}"
+        )
+    endif(SMTG_USE_STDATOMIC_H)
+    
+    target_include_directories(pluginterfaces
+        PUBLIC
+            ${SDK_ROOT}
+    )
+    
+    target_compile_features(pluginterfaces
+        PUBLIC
+            cxx_std_17
+    )
+    
+    smtg_target_setup_universal_binary(pluginterfaces)
+    
+    # iOS target
+    if(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+        smtg_create_ios_target_from_target(pluginterfaces)
+        set_target_properties(pluginterfaces_ios
+            PROPERTIES
+                ${SDK_IDE_LIBS_FOLDER}
+        )
+    endif()
+
+endfunction()
+
+#------------------------------------------------------------------------
+function(smtg_create_public_sdk_common_target)
+
+    add_library(sdk_common
+        STATIC
+            ${SDK_ROOT}/public.sdk/source/common/commoniids.cpp
+            ${SDK_ROOT}/public.sdk/source/common/commonstringconvert.cpp
+            ${SDK_ROOT}/public.sdk/source/common/commonstringconvert.h
+            ${SDK_ROOT}/public.sdk/source/common/openurl.cpp
+            ${SDK_ROOT}/public.sdk/source/common/openurl.h
+            ${SDK_ROOT}/public.sdk/source/common/systemclipboard.h
+            ${SDK_ROOT}/public.sdk/source/common/systemclipboard_linux.cpp
+            ${SDK_ROOT}/public.sdk/source/common/systemclipboard_win32.cpp
+            ${SDK_ROOT}/public.sdk/source/common/threadchecker.h
+            ${SDK_ROOT}/public.sdk/source/common/threadchecker_linux.cpp
+            ${SDK_ROOT}/public.sdk/source/common/threadchecker_win32.cpp
+            ${SDK_ROOT}/public.sdk/source/common/readfile.cpp
+            ${SDK_ROOT}/public.sdk/source/common/readfile.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstpresetfile.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstpresetfile.h
+    )
+
+    if(SMTG_MAC)
+        target_sources(sdk_common 
+            PRIVATE
+                ${SDK_ROOT}/public.sdk/source/common/threadchecker_mac.mm
+                ${SDK_ROOT}/public.sdk/source/common/systemclipboard_mac.mm
+        )
+    endif(SMTG_MAC)
+
+    # add dependencies
+    target_link_libraries(sdk_common 
+        PUBLIC 
+            base
+            pluginterfaces
+    )
+    target_include_directories(sdk_common
+        PUBLIC
+            ${SDK_ROOT}
+    )
+    smtg_target_setup_universal_binary(sdk_common)
+
+    if(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+        smtg_create_ios_target_from_target(sdk_common)
+        set_target_properties(sdk_common_ios
+            PROPERTIES
+                ${SDK_IDE_LIBS_FOLDER}
+        )
+        target_link_libraries(sdk_common_ios 
+            PUBLIC 
+                base_ios
+                pluginterfaces_ios
+        )
+    endif()
+
+endfunction()
+
+#------------------------------------------------------------------------
+function(smtg_create_public_sdk_target)
+
+    add_library(sdk
+        STATIC 
+            ${SDK_ROOT}/public.sdk/source/common/pluginview.cpp
+            ${SDK_ROOT}/public.sdk/source/common/pluginview.h
+            ${SDK_ROOT}/public.sdk/source/main/pluginfactory.cpp
+            ${SDK_ROOT}/public.sdk/source/main/pluginfactory.h
+            ${SDK_ROOT}/public.sdk/source/main/pluginfactory_constexpr.h
+            ${SDK_ROOT}/public.sdk/source/main/moduleinit.cpp
+            ${SDK_ROOT}/public.sdk/source/main/moduleinit.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/alignedalloc.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/audiobuffers.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/dataexchange.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/utility/dataexchange.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/memoryibstream.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/processcontextrequirements.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/processdataslicer.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/ringbuffer.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/rttransfer.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/sampleaccurate.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/stringconvert.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/utility/stringconvert.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/systemtime.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/systemtime.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/utility/testing.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/utility/testing.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/vst2persistence.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/vst2persistence.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstaudioeffect.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstaudioeffect.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstbus.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstbus.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstbypassprocessor.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstcomponent.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstcomponent.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstcomponentbase.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstcomponentbase.h
+            ${SDK_ROOT}/public.sdk/source/vst/vsteditcontroller.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vsteditcontroller.h
+            ${SDK_ROOT}/public.sdk/source/vst/vsteventshelper.h
+            ${SDK_ROOT}/public.sdk/source/vst/vsthelpers.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstinitiids.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstnoteexpressiontypes.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstnoteexpressiontypes.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstparameters.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstparameters.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstrepresentation.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/vstrepresentation.h
+    )
+
+    target_compile_features(sdk
+        PUBLIC
+            cxx_std_17
+    )
+    
+    # add dependencies
+    target_link_libraries(sdk 
+        PUBLIC 
+            sdk_common
+    )
+    target_include_directories(sdk
+        PUBLIC
+            ${SDK_ROOT}
+    )
+    smtg_target_setup_universal_binary(sdk)
+    get_target_property(sdk_SOURCES sdk SOURCES)
+    
+    # iOS target
+    if(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+        smtg_create_ios_target_from_target(sdk)
+        set_target_properties(sdk_ios
+            PROPERTIES
+                ${SDK_IDE_LIBS_FOLDER}
+        )
+        target_link_libraries(sdk_ios
+            PUBLIC 
+                sdk_common_ios
+        )
+    endif(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+
+endfunction()
+
+#------------------------------------------------------------------------
+function(smtg_create_public_sdk_hosting_target)
+
+    add_library(sdk_hosting 
+        STATIC
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/connectionproxy.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/connectionproxy.h
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/eventlist.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/eventlist.h
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/hostclasses.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/hostclasses.h
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/module.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/module.h
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/parameterchanges.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/parameterchanges.h
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/pluginterfacesupport.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/pluginterfacesupport.h
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/processdata.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/hosting/processdata.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/optional.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/stringconvert.cpp
+            ${SDK_ROOT}/public.sdk/source/vst/utility/stringconvert.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/uid.h
+            ${SDK_ROOT}/public.sdk/source/vst/utility/versionparser.h
+            ${SDK_ROOT}/public.sdk/source/vst/vstinitiids.cpp
+    )
+    # add dependencies
+    target_link_libraries(sdk_hosting 
+        PUBLIC 
+            sdk_common
+    )
+    target_include_directories(sdk_hosting
+        PUBLIC
+            ${SDK_ROOT}
+    )
+    smtg_target_setup_universal_binary(sdk_hosting)
+
+    # iOS target for hosting
+    if(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+        smtg_create_ios_target_from_target(sdk_hosting)
+        set_target_properties(sdk_hosting_ios
+            PROPERTIES
+                ${SDK_IDE_LIBS_FOLDER}
+        )
+        target_link_libraries(sdk_hosting_ios 
+            PUBLIC 
+                sdk_common_ios
+        )
+        target_include_directories(sdk_hosting_ios
+            PUBLIC
+                ${SDK_ROOT}
+        )
+    endif(SMTG_MAC AND XCODE AND SMTG_ENABLE_IOS_TARGETS)
+
+endfunction()

engine/vendor/vst3sdk/cmake/modules/SMTG_VstGuiSupport.cmake

@@ -0,0 +1,127 @@
+
+#------------------------------------------------------------------------
+
+macro(smtg_add_vstgui_subdirectory vstgui_SOURCE_DIR)
+    set(VSTGUI_DISABLE_UNITTESTS 1)
+    set(VSTGUI_STANDALONE_EXAMPLES OFF)
+    set(VSTGUI_STANDALONE ON)
+    set(VSTGUI_TOOLS OFF)
+
+    add_subdirectory(${vstgui_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/VSTGUI.build)
+endmacro()
+
+macro(smtg_target_setup_vstgui_deprecated_methods target)
+   if(VSTGUI_ENABLE_DEPRECATED_METHODS)
+        target_compile_definitions(${target} 
+            PUBLIC
+                VSTGUI_ENABLE_DEPRECATED_METHODS=1
+        )
+    else()
+        target_compile_definitions(${target} 
+            PUBLIC
+                VSTGUI_ENABLE_DEPRECATED_METHODS=0
+        )
+    endif()
+endmacro()
+
+macro(smtg_target_prepare_bundle target)
+    target_compile_definitions(${target}
+        PUBLIC
+            SMTG_MODULE_IS_BUNDLE=1
+    )
+
+    target_sources(${target}
+        PRIVATE
+            ${public_sdk_SOURCE_DIR}/source/vst/vstgui_win32_bundle_support.cpp
+            ${public_sdk_SOURCE_DIR}/source/vst/vstgui_win32_bundle_support.h
+    )
+endmacro()
+
+#[=======================================================================[.txt:
+  Adds VSTGUI support.
+  
+  Usage:
+    smtg_enable_vstgui_support(VSTGUI_SOURCE_DIR "<path-to-the-vstgui-source-folder>")
+
+  Exports:
+    smtg_enable_vstgui_support exports "<path-to-the-vstgui-source-folder>" 
+    as SMTG_VSTGUI_SOURCE_DIR to its parent scope.
+
+  Deprecation:
+    The usage wihout parameters is depricated.
+    SMTG_VSTGUI_ROOT is exported for compatibility reasons and is also depricated.
+    Replace "${SMTG_VSTGUI_ROOT}/vstgui4" with "${SMTG_VSTGUI_SOURCE_DIR}".
+    The export of "${SMTG_VSTGUI_ROOT}" may be removed in future SDK versions.
+
+#]=======================================================================]
+function(smtg_enable_vstgui_support)
+    if(${ARGC} GREATER 0)
+        set(options)
+        set(oneValueArgs VSTGUI_SOURCE_DIR)
+        set(multiValueArgs)
+        cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+        if(ARG_UNPARSED_ARGUMENTS)
+            message(FATAL_ERROR "[SMTG] The following parameters are unrecognized: ${ARG_UNPARSED_ARGUMENTS}")
+        endif()
+        get_filename_component(vstgui_root "${ARG_VSTGUI_SOURCE_DIR}" DIRECTORY)
+        set(SMTG_VSTGUI_ROOT "${vstgui_root}" PARENT_SCOPE)
+        set(vstgui_source_dir "${ARG_VSTGUI_SOURCE_DIR}")
+    else()
+        # See function documentation for more information. 
+        message(DEPRECATION "[SMTG] Use smtg_enable_vstgui_support(VSTGUI_SOURCE_DIR \"<vstgui-source-folder>\") "
+                            "instead of set(SMTG_VSTGUI_ROOT \"<parrent-of-vstgui-source-dir>\") and smtg_enable_vstgui_support()")
+        set(vstgui_source_dir "${SMTG_VSTGUI_ROOT}/vstgui4")
+    endif()
+    # Export SMTG_VSTGUI_SOURCE_DIR to parent scope
+    set(SMTG_VSTGUI_SOURCE_DIR "${vstgui_source_dir}" PARENT_SCOPE)
+
+    message(STATUS "[SMTG] SMTG_VSTGUI_SOURCE_DIR is set to: ${vstgui_source_dir}")
+
+    smtg_add_vstgui_subdirectory(${vstgui_source_dir})
+
+    add_library(vstgui_support
+        STATIC 
+            ${vstgui_source_dir}/vstgui/plugin-bindings/vst3groupcontroller.cpp
+            ${vstgui_source_dir}/vstgui/plugin-bindings/vst3groupcontroller.h
+            ${vstgui_source_dir}/vstgui/plugin-bindings/vst3padcontroller.cpp
+            ${vstgui_source_dir}/vstgui/plugin-bindings/vst3padcontroller.h
+            ${vstgui_source_dir}/vstgui/plugin-bindings/vst3editor.cpp
+            ${vstgui_source_dir}/vstgui/plugin-bindings/vst3editor.h
+
+            ${public_sdk_SOURCE_DIR}/source/vst/vstguieditor.cpp
+    )
+
+    target_link_libraries(vstgui_support 
+        PUBLIC
+            base
+            vstgui
+            vstgui_uidescription
+    )
+
+    target_include_directories(vstgui_support
+        PUBLIC
+            ${vstgui_source_dir}
+    )
+    
+    target_compile_definitions(vstgui_support
+        PUBLIC 
+            $<$<CONFIG:Debug>:VSTGUI_LIVE_EDITING>
+    )
+
+    smtg_target_setup_vstgui_deprecated_methods(vstgui_support)
+
+    smtg_target_setup_universal_binary(vstgui_support)
+    smtg_target_setup_universal_binary(vstgui)
+    smtg_target_setup_universal_binary(vstgui_uidescription)
+
+    if(SMTG_WIN AND SMTG_CREATE_BUNDLE_FOR_WINDOWS)
+        smtg_target_prepare_bundle(vstgui_support)
+    endif()
+    if(SMTG_LINUX)
+        target_sources(vstgui_support
+            PRIVATE
+                ${public_sdk_SOURCE_DIR}/source/vst/vstgui_linux_runloop_support.cpp
+                ${public_sdk_SOURCE_DIR}/source/vst/vstgui_linux_runloop_support.h
+        )
+    endif()
+endfunction()