civ/hot-step-cpp-ROCm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial release

Browse Source
This commit is contained in:
civ
2026-08-16 18:24:52 +07:00
commit 876886a39a
13244 changed files with 2353959 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
engine/vendor/vst3sdk/cmake/LICENSE.txt
Vendored
+24
View File
@@ -0,0 +1,24 @@
//-----------------------------------------------------------------------------
MIT License
Copyright (c) 2025, Steinberg Media Technologies GmbH
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
//---------------------------------------------------------------------------------
engine/vendor/vst3sdk/cmake/README.md
Vendored
+88
View File
@@ -0,0 +1,88 @@
# Welcome to VST 3 SDK cmake
This repository contains Steinberg's [cmake modules](https://cmake.org/cmake/help/latest/manual/cmake-modules.7.html) and template files which can be used to create **VST 3** plug-ins for platforms like Windows, macOS, iOS and Linux.
For more information about cmake visit [cmake.org](https:://www.cmake.org/).
## Dependency map
In order to build a plug-in successfully, it only needs to link to ```sdk``` library. [VSTGUI](https://steinbergmedia.github.io/vst3_dev_portal/pages/What+is+the+VST+3+SDK/VSTGUI.html) is optional and can be used by linking to ```vstgui_support```.
The following figure shows the dependency map by using AGain, [EditorHost](https://steinbergmedia.github.io/vst3_dev_portal/pages/What+is+the+VST+3+SDK/EditorHost.html) and [VST3Inspector](https://steinbergmedia.github.io/vst3_dev_portal/pages/What+is+the+VST+3+SDK/VST3Inspector.html):
```tree
again
+-- sdk
| +-- sdk_common
| +-- base
| +-- pluginterfaces
|
+-- vstgui_support
+-- base
+-- vstgui_uidescription
+-- vstgui
```
```tree
editorhost
+-- sdk_hosting
+-- sdk_common
+-- base
+-- pluginterfaces
```
```tree
VST3Inspector
+-- vstgui_uidescription
| +-- vstgui
+-- vstgui_standalone
+-- vstgui
```
## Naming conventions and guidelines
Steinberg module, macro, function and variable names have the prefix ```SMTG_``` or ```smtg_``` in order to avoid name clashes.
### File namings
Steinberg module names are written in camel case and have the prefix ```SMTG_```.
Examples:
```c
SMTG_AddVST3Library.cmake
SMTG_DetectPlatform.cmake
SMTG_ConfigureCmakeGenerator.cmake
```
### Macro and function namings
Steinberg macro and function names are written in lower case and have the prefix ```smtg_``` followed by a verb.
Examples:
```c
smtg_detect_platform
smtg_configure_cmake_generator
smtg_setup_symbol_visibility
smtg_detect_xcode_version
```
### Variable namings
Steinberg variable names are written in upper case and have the prefix ```SMTG_```.
Examples:
```c
SMTG_PLUGIN_BINARY_DIR
SMTG_PLUGIN_EXTENSION
SMTG_PLUGIN_PACKAGE_NAME
```
## License & Usage guidelines
More details can be found at [www.steinberg.net/sdklicenses_vst3](http://www.steinberg.net/sdklicenses_vst3)
----
Return to [VST 3 SDK](https://github.com/steinbergmedia/vst3sdk)
engine/vendor/vst3sdk/cmake/modules/SMTG_AAXSupport.cmake
Vendored
+37
View File
@@ -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
Vendored
+73
View File
@@ -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
Vendored
+39
View File
@@ -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
Vendored
+641
View File
@@ -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
Vendored
+13
View File
@@ -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
Vendored
+151
View File
@@ -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
Vendored
+227
View File
@@ -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
Vendored
+314
View File
@@ -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
Vendored
+7
View File
@@ -0,0 +1,7 @@
#-------------------------------------------------------------------------------
# Includes
#-------------------------------------------------------------------------------
include(SMTG_SetupVST3LibraryDefaultPath)
include(SMTG_AddCommonOptions)
engine/vendor/vst3sdk/cmake/modules/SMTG_Bundle.cmake
Vendored
+170
View File
@@ -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
Vendored
+86
View File
@@ -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
Vendored
+49
View File
@@ -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
Vendored
+82
View File
@@ -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
Vendored
+48
View File
@@ -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
Vendored
+62
View File
@@ -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
Vendored
+40
View File
@@ -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
Vendored
+61
View File
@@ -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
Vendored
+28
View File
@@ -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
Vendored
+41
View File
@@ -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
Vendored
+41
View File
@@ -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
Vendored
+123
View File
@@ -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
Vendored
+34
View File
@@ -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
Vendored
+21
View File
@@ -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
Vendored
+37
View File
@@ -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
Vendored
+50
View File
@@ -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
Vendored
+45
View File
@@ -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
Vendored
+394
View File
@@ -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
Vendored
+127
View File
@@ -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()
engine/vendor/vst3sdk/cmake/templates/VST_Logo_Steinberg.ico
Vendored
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 248 KiB

engine/vendor/vst3sdk/cmake/templates/desktop.ini.in
Vendored
+2
View File
@@ -0,0 +1,2 @@
[.ShellClassInfo]
IconResource=PlugIn.ico,0
engine/vendor/vst3sdk/cmake/templates/projectversion.h.in
Vendored
+55
View File
@@ -0,0 +1,55 @@
//------------------------------------------------------------------------
// Project : VST SDK
//
// Category : cmake
// Filename : cmake/templates/projectversion.h.in
// Created by : Steinberg, 03/2022
// Description : cmake template file to generate the projectversion.h
//
//-----------------------------------------------------------------------------
// LICENSE
// (c) 2022, Steinberg Media Technologies GmbH, All Rights Reserved
//-----------------------------------------------------------------------------
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Steinberg Media Technologies nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//-----------------------------------------------------------------------------
#pragma once
#define MAJOR_VERSION_STR "@PROJECT_VERSION_MAJOR@"
#define MAJOR_VERSION_INT @PROJECT_VERSION_MAJOR@
#define SUB_VERSION_STR "@PROJECT_VERSION_MINOR@"
#define SUB_VERSION_INT @PROJECT_VERSION_MINOR@
#define RELEASE_NUMBER_STR "@PROJECT_VERSION_PATCH@"
#define RELEASE_NUMBER_INT @PROJECT_VERSION_PATCH@
#define BUILD_NUMBER_STR "@PROJECT_VERSION_TWEAK@" // Build number to be sure that each result could identified.
#define BUILD_NUMBER_INT @PROJECT_VERSION_TWEAK@
// Version possibly with build number (example "1.0.3.342")
#define FULL_VERSION_STR "@PROJECT_VERSION@"
// Version without build number (example "1.0.3")
#define VERSION_STR "@SMTG_PROJECT_VERSION@"