civ/hot-step-cpp-ROCm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
876886a39a280430aa6d171c2ad1fefaf1eb4ad8
hot-step-cpp-ROCm/engine/vendor/vst3sdk/cmake/modules/SMTG_AddSMTGLibrary.cmake
T
civ 876886a39a Initial release
2026-08-16 18:24:52 +07:00

642 lines
28 KiB
CMake
Raw Blame History

#-------------------------------------------------------------------------------
# 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)
Reference in New Issue View Git Blame Copy Permalink