212 lines
6.8 KiB
CMake
212 lines
6.8 KiB
CMake
get_filename_component(BASE_PATH "${CMAKE_CURRENT_LIST_FILE}" PATH)
|
|
|
|
#message(FATAL_ERROR "PATH ${BASE_PATH}")
|
|
|
|
# define macros to build core components
|
|
include("${BASE_PATH}/CMakeMacroParseArguments.cmake")
|
|
|
|
|
|
macro(_cgv_install_public_headers base)
|
|
_cgv_install_public_files(${base} ${INSTALL_HEADER_PATH} ${ARGN})
|
|
endmacro()
|
|
|
|
macro(_cgv_install_shader_files base)
|
|
_cgv_install_public_files(${base} ${INSTALL_SHADER_PATH} ${ARGN})
|
|
endmacro()
|
|
|
|
macro(_cgv_install_resource_files base)
|
|
_cgv_install_public_files(${base} ${INSTALL_RESOURCE_PATH} ${ARGN})
|
|
endmacro()
|
|
|
|
|
|
macro(_cgv_install_public_files base destbase)
|
|
set(HEADERS ${ARGN})
|
|
if (HEADERS)
|
|
foreach(header ${HEADERS})
|
|
if (IS_ABSOLUTE ${header})
|
|
# The header path is absolute. Check if this header is inside the build folder
|
|
set(HB_PATH "${CMAKE_BINARY_DIR}/${BUILD_BASE}/${destbase}/${base}")
|
|
file(RELATIVE_PATH PUBH_REL "${HB_PATH}" "${header}")
|
|
|
|
if (IS_ABSOLUTE "${PUBH_REL}")
|
|
message(FATAL_ERROR "Cannot install file ${header} as it has an absolute path that is outside of the project binaries dir!")
|
|
endif()
|
|
get_filename_component(PUBH_REL "${PUBH_REL}" PATH)
|
|
|
|
else()
|
|
get_filename_component(PUBH_REL "${header}" PATH)
|
|
endif()
|
|
install(FILES ${header} DESTINATION "${INSTALL_BASE}/${destbase}/${base}/${PUBH_REL}")
|
|
endforeach()
|
|
endif()
|
|
endmacro()
|
|
|
|
|
|
|
|
macro(_cgv_set_cxx_standard target)
|
|
# Set the language standard
|
|
# FIXME: The following will not work in windows. The correct approach would be
|
|
# set_property(TARGET ${target_name} PROPERTY CXX_STANDARD ${CXX_STANDARD})
|
|
# which is not supported. So for now we hack this property in
|
|
set(CMAKE_CXX_FLAGS "-std=c++11")
|
|
endmacro()
|
|
|
|
|
|
macro(_cgv_set_definitions target)
|
|
parse_arguments(DEFS "SHARED;STATIC;COMMON" "" ${ARGN})
|
|
|
|
set(${target}_SHARED_DEFINITIONS ${${target}_SHARED_DEFINITIONS} ${DEFS_COMMON} ${DEFS_SHARED})
|
|
set(${target}_STATIC_DEFINITIONS ${${target}_STATIC_DEFINITIONS} ${DEFS_COMMON} ${DEFS_STATIC})
|
|
set(${target}_COMMON_DEFINITIONS ${${target}_COMMON_DEFINITIONS} ${DEFS_COMMON} ${DEFS_STATIC})
|
|
|
|
if (${target}_SHARED_DEFINITIONS)
|
|
list(REMOVE_DUPLICATES ${target}_SHARED_DEFINITIONS)
|
|
endif()
|
|
if (${target}_STATIC_DEFINITIONS)
|
|
list(REMOVE_DUPLICATES ${target}_STATIC_DEFINITIONS)
|
|
endif()
|
|
|
|
set_target_properties(${target} PROPERTIES
|
|
_SHARED_DEFINITIONS "${${target}_SHARED_DEFINITIONS}"
|
|
_STATIC_DEFINITIONS "${${target}_STATIC_DEFINITIONS}"
|
|
_COMMON_DEFINITIONS "${${target}_COMMON_DEFINITIONS}")
|
|
|
|
if (BUILD_SHARED_LIBS)
|
|
set_target_properties(${target} PROPERTIES COMPILE_DEFINITIONS "${${target}_SHARED_DEFINITIONS}")
|
|
else()
|
|
set_target_properties(${target} PROPERTIES COMPILE_DEFINITIONS "${${target}_STATIC_DEFINITIONS}")
|
|
endif()
|
|
endmacro()
|
|
|
|
|
|
macro(cgv_add_export_definitions target)
|
|
|
|
set(SHARED_DEFS "")
|
|
set(STATIC_DEFS "")
|
|
|
|
foreach(def ${ARGN})
|
|
string(TOUPPER "${def}" DEF_UPPER)
|
|
set(SHARED_DEFS ${SHARED_DEFS} "${DEF_UPPER}_EXPORTS")
|
|
set(STATIC_DEFS ${STATIC_DEFS} "${DEF_UPPER}_FORCE_STATIC")
|
|
endforeach()
|
|
|
|
_cgv_set_definitions(${target}
|
|
SHARED ${SHARED_DEFS}
|
|
STATIC ${STATIC_DEFS})
|
|
endmacro()
|
|
|
|
|
|
macro(cgv_add_module target)
|
|
|
|
parse_arguments(DEFS "SOURCES;SHADERS;FILES" "" ${ARGN})
|
|
|
|
if (NOT DEFS_SOURCES AND NOT DEFS_SHADERS AND NOT DEFS_FILES)
|
|
set(DEFS_SOURCES ${ARGN})
|
|
set(DEFS_SHADERS "")
|
|
set(DEFS_FILES "")
|
|
endif()
|
|
|
|
if (BUILD_SHARED_LIBS)
|
|
add_library(${target} MODULE ${DEFS_SOURCES})
|
|
else()
|
|
add_library(${target} STATIC ${DEFS_SOURCES})
|
|
endif()
|
|
|
|
string(TOUPPER ${target} TARGET_UPPER)
|
|
_cgv_set_definitions(${target}
|
|
COMMON _UNICODE UNICODE
|
|
SHARED "_USRDLL"
|
|
STATIC "${TARGET_UPPER}_FORCE_STATIC;CGV_FORCE_STATIC")
|
|
|
|
set_target_properties(${target} PROPERTIES FOLDER "${FOLDER_NAME_PLUGINS}")
|
|
install(TARGETS ${target} DESTINATION "${INSTALL_BASE}/${INSTALL_LIB_PATH}")
|
|
_cgv_install_shader_files("${target}" ${DEFS_SHADERS})
|
|
_cgv_install_resource_files("${target}" ${DEFS_FILES})
|
|
|
|
# Set the cxx standard
|
|
_cgv_set_cxx_standard(${target})
|
|
|
|
# Remember the type for later config generation
|
|
set_target_properties(${target} PROPERTIES HEADER_LOCAL_PATH "plugins")
|
|
endmacro()
|
|
|
|
|
|
macro(cgv_add_executable target_name)
|
|
add_executable(${target_name} ${ARGN})
|
|
_cgv_set_definitions(${target_name}
|
|
COMMON UNICODE _UNICODE
|
|
STATIC CGV_FORCE_STATIC)
|
|
install(TARGETS ${target_name} DESTINATION "${INSTALL_BASE}/${INSTALL_BIN_PATH}" EXPORT ${target_name}Depends)
|
|
|
|
# There is a bug in CMake in which postfixes are not automatically added.
|
|
set_target_properties(${target_name} PROPERTIES
|
|
OUTPUT_NAME ${target_name}
|
|
RELEASE_OUTPUT_NAME ${target_name}
|
|
DEBUG_OUTPUT_NAME ${target_name}${DEBUG_POSTFIX})
|
|
|
|
# Set the relative path of needed dynamic libraries directly inside
|
|
# the binary on supported plattforms
|
|
file(RELATIVE_PATH REL_BIN_TO_LIB "/${INSTALL_BASE}/${INSTALL_BIN_PATH}" "/${INSTALL_BASE}/${INSTALL_LIB_PATH}")
|
|
set_target_properties(${target_name} PROPERTIES INSTALL_RPATH "\$ORIGIN/${REL_BIN_TO_LIB}")
|
|
|
|
# Set the language standard
|
|
_cgv_set_cxx_standard(${target_name})
|
|
|
|
|
|
# Remember the type for later config generation
|
|
set_target_properties(${target_name} PROPERTIES HEADER_LOCAL_PATH "apps")
|
|
endmacro()
|
|
|
|
|
|
macro(_cgv_add_custom_library target_name folder)
|
|
# Parse the argument list
|
|
parse_arguments(CONF "SOURCES;HEADERS;PUBLIC_HEADERS;SHARED_DEFINITIONS;STATIC_DEFINITIONS;DEFINITIONS;SHADERS;FILES;INSTALL_NAME" "" ${ARGN})
|
|
|
|
if (NOT CONF_INSTALL_NAME)
|
|
set(CONF_INSTALL_NAME ${target_name})
|
|
endif()
|
|
|
|
# Add a library
|
|
add_library(${target_name} ${CONF_SOURCES} ${CONF_HEADERS} ${CONF_PUBLIC_HEADERS})
|
|
|
|
# Set include directories
|
|
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
|
|
|
|
# Create installation rules for the target
|
|
install(TARGETS ${target_name} DESTINATION "${INSTALL_BASE}/${INSTALL_LIB_PATH}")
|
|
_cgv_install_public_headers("libs/${CONF_INSTALL_NAME}" ${CONF_PUBLIC_HEADERS})
|
|
_cgv_install_shader_files("${CONF_INSTALL_NAME}" ${CONF_SHADERS})
|
|
_cgv_install_resource_files("${CONF_INSTALL_NAME}" ${CONF_FILES})
|
|
|
|
|
|
# Remember the type and install name for later config generation
|
|
set_target_properties(${target_name} PROPERTIES
|
|
HEADER_LOCAL_PATH "libs"
|
|
HEADER_LOCAL_NAME ${CONF_INSTALL_NAME})
|
|
|
|
# Set the language standard
|
|
_cgv_set_cxx_standard(${target_name})
|
|
|
|
|
|
# Set a source folder for VisualStudio
|
|
set_target_properties(${target_name} PROPERTIES FOLDER "${folder}")
|
|
|
|
_cgv_set_definitions(${target_name}
|
|
COMMON "${CONF_DEFINITIONS}"
|
|
SHARED "${CONF_SHARED_DEFINITIONS}"
|
|
STATIC "${CONF_STATIC_DEFINITIONS};CGV_FORCE_STATIC")
|
|
endmacro()
|
|
|
|
|
|
macro(cgv_add_library target_name)
|
|
_cgv_add_custom_library(${target_name} "${FOLDER_NAME_LIBS}" "${ARGN}")
|
|
endmacro()
|
|
|
|
|
|
macro(cgv_add_3rd_library target_name)
|
|
_cgv_add_custom_library(${target_name} "${FOLDER_NAME_3RD}" "${ARGN}")
|
|
endmacro()
|
|
|
|
|
|
# Include macros that deal with the creation of config files
|
|
include("${BASE_PATH}/createConfigScript.cmake")
|