642 lines
28 KiB
CMake
642 lines
28 KiB
CMake
|
|
#-------------------------------------------------------------------------------
|
|
# 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)
|