From 944b3b9133e1388c98af9866a46d74ac94ab1b3a Mon Sep 17 00:00:00 2001 From: Jonathan Schmidt Date: Mon, 20 Feb 2017 16:09:07 -0500 Subject: [PATCH] Add cmake statib lib --- .gitignore | 1 + CMakeLists.txt | 47 ++++ cmake/CMakeCompiler.cmake | 57 +++++ cmake/CMakeMacros.cmake | 535 ++++++++++++++++++++++++++++++++++++++++++ cmake/CMakeManifest.cmake | 66 ++++++ cmake/CMakePlatforms.cmake | 118 ++++++++++ cmake/CMakeSettings.cmake | 231 ++++++++++++++++++ cmake/Toolchain-Android.cmake | 49 ++++ cmake/Toolchain-iOS.cmake | 104 ++++++++ stb_shared.c | 9 + 10 files changed, 1217 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 cmake/CMakeCompiler.cmake create mode 100644 cmake/CMakeMacros.cmake create mode 100644 cmake/CMakeManifest.cmake create mode 100644 cmake/CMakePlatforms.cmake create mode 100644 cmake/CMakeSettings.cmake create mode 100644 cmake/Toolchain-Android.cmake create mode 100644 cmake/Toolchain-iOS.cmake create mode 100644 stb_shared.c diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..567609b --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +build/ diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..a9ed9f1 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,47 @@ +cmake_minimum_required(VERSION 3.6) + +set(CMAKE_CONFIGURATION_TYPES "Debug;Dev;Release" + CACHE STRING + "List of supported configurations." + FORCE) + +project(stb) + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") +include(CMakeSettings) + +set(CMAKE_C_FLAGS) +set(CMAKE_CXX_FLAGS) +set(CMAKE_C_FLAGS_DEBUG "-D_DEBUG") +set(CMAKE_CXX_FLAGS_DEBUG "-D_DEBUG") +set(CMAKE_C_FLAGS_RELEASE "-DNDEBUG") +set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG") + +# Setup platforms +if( PLATFORM_WINDOWS ) + add_compile_options(-DWINDOWSPC) +endif() + +# Define standard configurations +if( CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES MATCHES "Debug;Dev;Release" ) + list(APPEND Configs Debug Dev Release) + set(CMAKE_CONFIGURATION_TYPES ${Configs} CACHE STRING "List of supported configurations." FORCE) + set(CMAKE_INSTALL_PREFIX $ENV{SR_BIN_DIR} CACHE STRING "Default installation directory." FORCE) + message(FATAL_ERROR "Default configuration was reset, please re-run CMake.") +endif() + +# Initialize the development configuration using release configuration +set(CMAKE_C_FLAGS_DEV "${CMAKE_C_FLAGS_RELEASE}") +set(CMAKE_CXX_FLAGS_DEV "${CMAKE_CXX_FLAGS_RELEASE}") +set(CMAKE_STATIC_LINKER_FLAGS_DEV "${CMAKE_STATIC_LINKER_FLAGS_RELEASE}") + +set(root ${CMAKE_CURRENT_SOURCE_DIR}) +set(INCLUDE_FILES ${root}/stb_image.h ${root}/stb_image_write.h) +set(ALL_SOURCE_FILES ${INCLUDE_FILES} ${root}/stb_shared.c) + +add_library(${PROJECT_NAME} STATIC ${ALL_SOURCE_FILES}) + +export(TARGETS ${PROJECT_NAME} APPEND FILE ${CMAKE_BINARY_DIR}/${PROJECT_NAME}-targets.cmake) + +install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}-targets DESTINATION lib/$>) +install(FILES ${INCLUDE_FILES} DESTINATION include) diff --git a/cmake/CMakeCompiler.cmake b/cmake/CMakeCompiler.cmake new file mode 100644 index 0000000..d58b0f9 --- /dev/null +++ b/cmake/CMakeCompiler.cmake @@ -0,0 +1,57 @@ +cmake_minimum_required(VERSION 3.6) + +# This module is shared; use include blocker. +if( _COMPILER_ ) + return() +endif() +set(_COMPILER_ 1) + +# Initialize MSVC version +if( "${CMAKE_GENERATOR}" MATCHES "Visual Studio" AND NOT MSVC_VERSION ) + set(MSVC10) + set(MSVC11) + set(MSVC12) + set(MSVC14) + set(MSVC 1) + set(MSVC_IDE 1) + if( "${CMAKE_GENERATOR}" MATCHES "Visual Studio 10 2010" ) + set(MSVC10 1) + set(MSVC_VERSION 1600) + elseif( "${CMAKE_GENERATOR}" MATCHES "Visual Studio 11 2012" ) + set(MSVC11 1) + set(MSVC_VERSION 1700) + elseif( "${CMAKE_GENERATOR}" MATCHES "Visual Studio 12 2013" ) + set(MSVC12 1) + set(MSVC_VERSION 1800) + elseif( "${CMAKE_GENERATOR}" MATCHES "Visual Studio 14 2015" ) + set(MSVC14 1) + set(MSVC_VERSION 1900) + else() + message(FATAL_ERROR "Unsupported Visual Studio version!") + endif() +endif() + +# Initialize compiler variables +if( "${CMAKE_GENERATOR}" MATCHES "Visual Studio" ) + if( MSVC_VERSION EQUAL 1600 ) + set(DEVENV_NAME "vs2010") + set(COMPILER_NAME "vc10") + elseif( MSVC_VERSION EQUAL 1700 ) + set(DEVENV_NAME "vs2012") + set(COMPILER_NAME "vc11") + elseif( MSVC_VERSION EQUAL 1800 ) + set(DEVENV_NAME "vs2013") + set(COMPILER_NAME "vc12") + elseif( MSVC_VERSION EQUAL 1900 ) + set(DEVENV_NAME "vs2015") + set(COMPILER_NAME "vc14") + else() + message(FATAL_ERROR "Missing Visual Studio version defines!") + endif() +elseif( "${CMAKE_GENERATOR}" MATCHES "Xcode" ) + set(DEVENV_NAME "xcode") + set(COMPILER_NAME "clang") +elseif( "${CMAKE_GENERATOR}" MATCHES "Makefile" ) + set(DEVENV_NAME) + set(COMPILER_NAME) +endif() diff --git a/cmake/CMakeMacros.cmake b/cmake/CMakeMacros.cmake new file mode 100644 index 0000000..2cf2c3b --- /dev/null +++ b/cmake/CMakeMacros.cmake @@ -0,0 +1,535 @@ +cmake_minimum_required(VERSION 3.6) + +# Set each source file proper source group +macro(set_source_groups pList) + foreach(FilePath ${pList}) + get_filename_component(DirName ${FilePath} DIRECTORY) + if( NOT "${DirName}" STREQUAL "" ) + string(REGEX REPLACE "[.][.][/]" "" GroupName "${DirName}") + string(REGEX REPLACE "/" "\\\\" GroupName "${GroupName}") + source_group("${GroupName}" FILES ${FilePath}) + else() + source_group("" FILES ${FilePath}) + endif() + endforeach() +endmacro() + +# Get all source files recursively and add them to pResult +macro(find_source_files_of_type pFileExtensions pResult) + set(FileList) + set(SearchDir "${ARGN}") + + # Retrive all source files recursively + if( "${SearchDir}" STREQUAL "" ) + file(GLOB_RECURSE FileList RELATIVE ${PROJECT_SOURCE_DIR} ${pFileExtensions}) + else() + set(UpdatedFileExtensions) + foreach(FileExtension ${pFileExtensions}) + list(APPEND UpdatedFileExtensions "${SearchDir}/${FileExtension}") + endforeach() + file(GLOB_RECURSE FileList RELATIVE ${PROJECT_SOURCE_DIR} ${UpdatedFileExtensions}) + endif() + list(APPEND ${pResult} ${FileList}) + + set_source_groups("${FileList}") +endmacro() + +# Get all source files recursively and add them to pResult +macro(find_source_files pResult) + set(FileList) + set(SearchDir "${ARGN}") + + # Retrive all source files recursively + set(FileExtensions) + list(APPEND FileExtensions "*.h" "*.c" "*.cpp" "*.inl") + if( PLATFORM_OSX OR PLATFORM_IOS ) + list(APPEND FileExtensions "*.m" "*.mm") + endif() + if( "${SearchDir}" STREQUAL "" ) + file(GLOB_RECURSE FileList RELATIVE ${PROJECT_SOURCE_DIR} ${FileExtensions}) + else() + set(UpdatedFileExtensions) + foreach(FileExtension ${FileExtensions}) + list(APPEND UpdatedFileExtensions "${SearchDir}/${FileExtension}") + endforeach() + file(GLOB_RECURSE FileList RELATIVE ${PROJECT_SOURCE_DIR} ${UpdatedFileExtensions}) + endif() + list(APPEND ${pResult} ${FileList}) + + set_source_groups("${FileList}") + + # Patch for Android compiler that refuse -std=c++11 flag on .c files. + # Normally we would use CMAKE_CXX_FLAGS to add this flag only to .cpp files, + # but somehow with NVidia NSight Tegra it also passes to .c files. + if( PLATFORM_ANDROID OR PLATFORM_WEBGL ) + foreach(FilePath ${FileList}) + get_filename_component(ExtName ${FilePath} EXT) + if( "${ExtName}" STREQUAL ".cpp" ) + set_source_files_properties(${FilePath} PROPERTIES COMPILE_FLAGS "-std=c++11") + endif() + endforeach() + endif() +endmacro() + +# Remove files matching the given base path(s) from the list +macro(remove_paths_from_list file_list_name) + set (files ${${file_list_name}}) + foreach(path ${ARGN}) + foreach(item IN LISTS files) + if(${item} MATCHES "${path}/.*") + LIST(REMOVE_ITEM ${file_list_name} ${item}) + endif(${item} MATCHES "${path}/.*") + endforeach(item) + endforeach(path) +endmacro() + +# Add compilation flags, configuration type is optional +macro(add_compile_flags pFlags) + set(MacroArgs "${ARGN}") + if( NOT MacroArgs ) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${pFlags}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${pFlags}") + else() + foreach(MacroArg IN LISTS MacroArgs) + if( MacroArg STREQUAL "debug" ) + set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${pFlags}") + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${pFlags}") + elseif( MacroArg STREQUAL "dev" ) + set(CMAKE_C_FLAGS_DEV "${CMAKE_C_FLAGS_DEV} ${pFlags}") + set(CMAKE_CXX_FLAGS_DEV "${CMAKE_CXX_FLAGS_DEV} ${pFlags}") + elseif( MacroArg STREQUAL "release" ) + set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${pFlags}") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${pFlags}") + else() + message(FATAL_ERROR "Unknown configuration ${MacroArg}, cannot add compile flags!") + endif() + endforeach() + endif() +endmacro() + +# Replace compilation flags, configuration type is optional +macro(replace_compile_flags pSearch pReplace) + set(MacroArgs "${ARGN}") + if( NOT MacroArgs ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + else() + foreach(MacroArg IN LISTS MacroArgs) + if( MacroArg STREQUAL "debug" ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") + elseif( MacroArg STREQUAL "dev" ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_C_FLAGS_DEV "${CMAKE_C_FLAGS_DEV}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_CXX_FLAGS_DEV "${CMAKE_CXX_FLAGS_DEV}") + elseif( MacroArg STREQUAL "release" ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}") + else() + message(FATAL_ERROR "Unknown configuration, cannot replace compile flags!") + endif() + endforeach() + endif() +endmacro() + +# Add linker flags, configuration type is optional +macro(add_linker_flags pFlags) + set(MacroArgs "${ARGN}") + if( NOT MacroArgs ) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${pFlags}") + set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${pFlags}") + else() + foreach(MacroArg IN LISTS MacroArgs) + if( MacroArg STREQUAL "debug" ) + set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${pFlags}") + set(CMAKE_STATIC_LINKER_FLAGS_DEBUG "${CMAKE_STATIC_LINKER_FLAGS_DEBUG} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} ${pFlags}") + elseif( MacroArg STREQUAL "dev" ) + set(CMAKE_EXE_LINKER_FLAGS_DEV "${CMAKE_EXE_LINKER_FLAGS_DEV} ${pFlags}") + set(CMAKE_STATIC_LINKER_FLAGS_DEV "${CMAKE_STATIC_LINKER_FLAGS_DEV} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS_DEV "${CMAKE_SHARED_LINKER_FLAGS_DEV} ${pFlags}") + elseif( MacroArg STREQUAL "release" ) + set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${pFlags}") + set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${pFlags}") + else() + message(FATAL_ERROR "Unknown configuration, cannot add linker flags!") + endif() + endforeach() + endif() +endmacro() + +# Add exe linker flags, configuration type is optional +macro(add_exe_linker_flags pFlags) + set(MacroArgs "${ARGN}") + if( NOT MacroArgs ) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${pFlags}") + set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${pFlags}") + else() + foreach(MacroArg IN LISTS MacroArgs) + if( MacroArg STREQUAL "debug" ) + set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} ${pFlags}") + set(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} ${pFlags}") + elseif( MacroArg STREQUAL "dev" ) + set(CMAKE_EXE_LINKER_FLAGS_DEV "${CMAKE_EXE_LINKER_FLAGS_DEV} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS_DEV "${CMAKE_SHARED_LINKER_FLAGS_DEV} ${pFlags}") + set(CMAKE_MODULE_LINKER_FLAGS_DEV "${CMAKE_MODULE_LINKER_FLAGS_DEV} ${pFlags}") + elseif( MacroArg STREQUAL "release" ) + set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${pFlags}") + set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${pFlags}") + set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${pFlags}") + else() + message(FATAL_ERROR "Unknown configuration, cannot add linker flags!") + endif() + endforeach() + endif() +endmacro() + +# Replace linker flags, configuration type is optional +macro(replace_linker_flags pSearch pReplace) + set(MacroArgs "${ARGN}") + if( NOT MacroArgs ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}") + else() + foreach(MacroArg IN LISTS MacroArgs) + if( MacroArg STREQUAL "debug" ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}") + elseif( MacroArg STREQUAL "dev" ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_EXE_LINKER_FLAGS_DEV "${CMAKE_EXE_LINKER_FLAGS_DEV}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_SHARED_LINKER_FLAGS_DEV "${CMAKE_SHARED_LINKER_FLAGS_DEV}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_MODULE_LINKER_FLAGS_DEV "${CMAKE_MODULE_LINKER_FLAGS_DEV}") + elseif( MacroArg STREQUAL "release" ) + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") + string(REGEX REPLACE "${pSearch}" "${pReplace}" CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE}") + else() + message(FATAL_ERROR "Unknown configuration, cannot replace linker flags!") + endif() + endforeach() + endif() +endmacro() + +# Used to find and link an IOS framework +macro(target_link_ios_framework) + set(PROJ_NAME ${ARGV0}) + set(NAME ${ARGV1}) + find_library(FRAMEWORK_${NAME} NAMES ${NAME} PATHS ${CMAKE_OSX_SYSROOT}/System/Library PATH_SUFFIXES Frameworks NO_DEFAULT_PATH) + mark_as_advanced(FRAMEWORK_${NAME}) + if( ${FRAMEWORK_${NAME}} STREQUAL FRAMEWORK_${NAME}-NOTFOUND ) + message(ERROR ": Framework ${NAME} not found") + else() + target_link_libraries(${PROJ_NAME} ${FRAMEWORK_${NAME}}) + message(STATUS "Found Framework ${NAME}: ${FRAMEWORK_${NAME}}") + endif() +endmacro() + +# Used to link Android specific library types, such as .so/.jar/.aar +macro(target_link_android_libraries target libs) + foreach(_lib ${libs}) + if( "${_lib}" MATCHES "^.*\\.so$" ) + # Add native library directory only once + get_target_property(_lib_dirs ${PROJECT_NAME} ANDROID_NATIVE_LIB_DIRECTORIES) + get_filename_component(_lib_dir ${_lib} DIRECTORY) + if( NOT "${_lib_dirs}" MATCHES "${_lib_dir}" ) + set_property(TARGET ${target} APPEND PROPERTY ANDROID_NATIVE_LIB_DIRECTORIES ${_lib_dir}) + endif() + # Add native libraries dependencies + get_filename_component(_lib_name ${_lib} NAME_WE) + if( "${_lib_name}" MATCHES "^lib.*$" ) + string(SUBSTRING ${_lib_name} 3 -1 _lib_name) + endif() + set_property(TARGET ${target} APPEND PROPERTY ANDROID_NATIVE_LIB_DEPENDENCIES ${_lib_name}) + elseif( "${_lib}" MATCHES "^.*\\.jar$" ) + # Add jar directory only once + get_target_property(_lib_dirs ${PROJECT_NAME} ANDROID_JAR_DIRECTORIES) + get_filename_component(_lib_dir ${_lib} DIRECTORY) + if( NOT "${_lib_dirs}" MATCHES "${_lib_dir}" ) + set_property(TARGET ${target} APPEND PROPERTY ANDROID_JAR_DIRECTORIES ${_lib_dir}) + endif() + # Add jar dependencies + get_filename_component(_lib_name ${_lib} NAME_WE) + if( "${_lib_name}" MATCHES "^lib.*$" ) + string(SUBSTRING ${_lib_name} 3 -1 _lib_name) + endif() + set_property(TARGET ${target} APPEND PROPERTY ANDROID_JAR_DEPENDENCIES ${_lib_name}) + elseif( "${_lib}" MATCHES "^.*\\.aar$" ) + # Simply copy aar library into project binary libs dir to be compiled by Gradle + file(COPY ${_lib} DESTINATION ${${target}_BINARY_DIR}/libs) + endif() + endforeach() +endmacro() + +# Ask source control for revision number to include in a build header file +# If pResult already has a value this function does nothing +macro(determine_build_revision pBaseDir pResult) + if( NOT ${pResult} ) + execute_process(COMMAND git log -1 --format=%H WORKING_DIRECTORY ${pBaseDir} OUTPUT_VARIABLE ${pResult} OUTPUT_STRIP_TRAILING_WHITESPACE) + endif() + if( NOT ${pResult} ) + execute_process(COMMAND hg identify -i WORKING_DIRECTORY ${pBaseDir} OUTPUT_VARIABLE ${pResult} OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) + endif() + if( NOT ${pResult} ) + execute_process(COMMAND svn info WORKING_DIRECTORY ${pBaseDir} OUTPUT_VARIABLE OUTPUT_SVN OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) + if( OUTPUT_SVN ) + string(REGEX MATCH "Last Changed Rev: [0-9]+" OUTPUT_SVN_LAST_CHANGED_REV_LINE ${OUTPUT_SVN}) + if( OUTPUT_SVN_LAST_CHANGED_REV_LINE ) + string(REGEX MATCH "[0-9]+" OUTPUT_SVN_LAST_CHANGED_REV ${OUTPUT_SVN_LAST_CHANGED_REV_LINE}) + if( OUTPUT_SVN_LAST_CHANGED_REV ) + set(${pResult} ${OUTPUT_SVN_LAST_CHANGED_REV}) + endif() + endif() + endif() + endif() + if( NOT ${pResult} ) + execute_process(COMMAND p4 changes -m 1 -s submitted "#have" WORKING_DIRECTORY ${pBaseDir} OUTPUT_VARIABLE OUTPUT_P4 OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET TIMEOUT 5) + if( OUTPUT_P4 ) + string(REGEX MATCH "[0-9]+" OUTPUT_P4_CL ${OUTPUT_P4}) + if( OUTPUT_P4_CL ) + set(${pResult} ${OUTPUT_P4_CL}) + endif() + endif() + endif() + if( NOT ${pResult} ) + set(${pResult} "unknown") + endif() +endmacro() + +# Set a variable to pValue if pValue exists, otherwise set it to pDefault +macro(set_default pResult pValue pDefault) + set(${pResult} ${pValue}) + if( NOT ${pResult} ) + set(${pResult} ${pDefault}) + endif() +endmacro() + +# Generate the package location cache +macro(generate_package_location_cache) + set(SpmCmd) + list(APPEND SpmCmd "ruby" "${REPOSITORY_DIR}/spm.rb" "locate" "-a") + if( PLATFORM_WINDOWS ) + list(APPEND SpmCmd "-p" "win${ARCH_BITS}") + elseif( PLATFORM_WINUWP ) + list(APPEND SpmCmd "-p" "winuwp${ARCH_BITS}") + else() + list(APPEND SpmCmd "-p" "${PLATFORM_NAME}") + endif() + if( PLATFORM_WINDOWS OR PLATFORM_XBOXONE) + list(APPEND SpmCmd "-d" "${COMPILER_NAME}") + endif() + execute_process(COMMAND ${SpmCmd} WORKING_DIRECTORY ${REPOSITORY_DIR} RESULT_VARIABLE ProcessResult OUTPUT_VARIABLE SpmOutput OUTPUT_STRIP_TRAILING_WHITESPACE) + if( NOT ProcessResult EQUAL 0 ) + message(FATAL_ERROR "Failed to execute spm.rb to locate packages!") + endif() + file(WRITE ${PACKAGE_CACHE_FILE} ${SpmOutput}) +endmacro() + +# Find package root folder. Can be overwritten with environment variable SR__ROOT. +macro(find_package_root pResult pPackageName) + if( ${pResult} ) + return() + endif() + set(PackageLocation) + set(AlternatePackageLocation $ENV{SR_${pResult}}) + if( DEFINED AlternatePackageLocation ) + string(REPLACE "\\" "/" PackageLocation ${AlternatePackageLocation}) + else() + if( NOT EXISTS "${PACKAGE_CACHE_FILE}" ) + message(FATAL_ERROR "Package location cache file not found! Expected to find it here: ${PACKAGE_CACHE_FILE}") + endif() + file(STRINGS ${PACKAGE_CACHE_FILE} PackageCache REGEX ".+ = .+") + foreach(Line ${PackageCache}) + if( "${Line}" MATCHES "${pPackageName}" ) + string(STRIP ${Line} Line) + string(REGEX REPLACE ".+ = " "" Line ${Line}) + string(REPLACE "\\" "/" PackageLocation ${Line}) + break() + endif() + endforeach() + endif() + if( NOT EXISTS "${PackageLocation}" OR NOT IS_DIRECTORY "${PackageLocation}" ) + message(FATAL_ERROR "Unable to find package '${pPackageName}' root folder!") + endif() + set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${PackageLocation}) + set(${pResult} ${PackageLocation}) +endmacro() + +# Encoding a list into a string using custom separator +macro(encode_list pResult pSeparator pList) + set(ENCODED_LIST) + foreach(ITEM ${pList}) + if( "${ENCODED_LIST}" STREQUAL "" ) + set(ENCODED_LIST "${ITEM}") + else() + set(ENCODED_LIST "${ENCODED_LIST}${pSeparator}${ITEM}") + endif() + endforeach() + set(${pResult} ${ENCODED_LIST}) +endmacro() + +# Decoding a custom separated string into a list +macro(decode_list pResult pSeparator pList) + string(REPLACE "${pSeparator}" ";" ${pResult} ${pList}) +endmacro() + +# Add files to the package manifest file +macro(add_package_manifest_files pTarget pFiles) + if( PLATFORM_WINDOWS ) + get_property(plugin_dll_filepath TARGET ${pTarget} PROPERTY PLUGIN_DLL_FILEPATH) + encode_list(ENCODED_FILE_LIST "*" "${pFiles}") + add_custom_command(TARGET ${pTarget} POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS + -DLOCKDIR="${CMAKE_BINARY_DIR}" + -DOUTDIR="${ENGINE_INSTALL_DIR}" + -DOUTFILE="package.manifest" + -DFILENAMES="${ENCODED_FILE_LIST}" + -DPLUGIN_DLL_FILEPATH="${plugin_dll_filepath}" + -P "${CMAKE_MODULE_PATH}/CMakeManifest.cmake" + ) + endif() +endmacro() + +# Add files found in directories to the package manifest file +macro(add_package_manifest_dirs pTarget pDirs) + if( PLATFORM_WINDOWS ) + encode_list(ENCODED_DIR_LIST "*" "${pDirs}") + add_custom_command(TARGET ${pTarget} POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS + -DLOCKDIR="${CMAKE_BINARY_DIR}" + -DOUTDIR="${ENGINE_INSTALL_DIR}" + -DOUTFILE="package.manifest" + -DDIRNAMES="${ENCODED_DIR_LIST}" + -P "${CMAKE_MODULE_PATH}/CMakeManifest.cmake" + ) + endif() +endmacro() + +# Used across projects to set platform specific flags +macro(set_system_properties pTarget) + if( PLATFORM_OSX OR PLATFORM_IOS ) + set_target_properties(${pTarget} PROPERTIES + XCODE_ATTRIBUTE_VALID_ARCHS "${CMAKE_OSX_ARCHITECTURES}" + ) + if( PLATFORM_IOS ) + set_target_properties(${pTarget} PROPERTIES + XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "${CMAKE_IOS_DEPLOYMENT_TARGET}" + XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY "1,2" + ) + endif() + elseif( PLATFORM_WINUWP ) + set_target_properties(${pTarget} PROPERTIES VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION "${UWP_VERSION_MIN}") + elseif( PLATFORM_XBOXONE ) + set_target_properties(${pTarget} PROPERTIES VS_GLOBAL_XdkEditionTarget "${XDK_TOOLCHAIN_VERSION}") + endif() +endmacro() + +# Used to add target link libraries that have circular dependencies. i.e. groups +macro(target_link_libraries_group pTarget pLibraries) + if( PLATFORM_WEBGL ) + target_link_libraries(${pTarget} -Wl,--start-group ${pLibraries} -Wl,--end-group) + elseif( PLATFORM_ANDROID ) + target_link_libraries(${pTarget} ${pLibraries}) + target_link_libraries(${pTarget} ${pLibraries}) + else() + target_link_libraries(${pTarget} ${pLibraries}) + endif() +endmacro() + +# Used to add target dependency with platform specific code +macro(add_dependencies_platform pTarget pDependencies) + if( PLATFORM_ANDROID ) + # Don't use add_dependencies to avoid linker dependencies between pTarget and pDependencies, + # which are undesirable when pDependencies are dynamic plugins. This seems to be a bug since + # libraries created with add_library(... MODULE ...) shouldn't create a linker dependency + # as opposed to add_library(... SHARED ...), according to the CMake documentation. + # The problem with not using `add_dependencies`, however, is that pDependencies may be built after pTarget + foreach(Dep ${pDependencies}) + get_target_property(DependencyOutputName ${Dep} OUTPUT_NAME) + set_property(TARGET ${pTarget} APPEND PROPERTY ANDROID_NATIVE_LIB_DEPENDENCIES ${DependencyOutputName}) + endforeach() + else() + add_dependencies(${pTarget} ${pDependencies}) + endif() +endmacro() + +macro(configure_plugin_linking plugin_name plugin_enabled_flag) + if( NOT BUILD_SHARED_LIBS ) + if (${plugin_enabled_flag}) + set(PLUGIN_NAME ${plugin_name}) + configure_file("${REPOSITORY_DIR}/runtime/plugins/plugin_static_linking.cpp.in" "${CMAKE_BINARY_DIR}/plugins/${plugin_name}_linking.cpp") + else() + file(REMOVE "${CMAKE_BINARY_DIR}/plugins/${plugin_name}_linking.cpp") + endif() + endif() +endmacro() + + +macro(set_plugin_runtime_output_directory target_name target_folder) + if (PLATFORM_WINDOWS) + # Safely clean out previously built dlls and copy them to the engine plugin folder - for hot reloading of plugins + add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${REPOSITORY_DIR}/runtime/plugins/hot-reload-post-link.bat ARGS "$(OutDir)" "${target_folder}" "${target_name}") + # Workaround for using the correct path in manifest generation + set_target_properties(${PROJECT_NAME} PROPERTIES PLUGIN_DLL_FILEPATH "${target_folder}/${target_name}.dll") + else() + set_target_properties(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${target_folder}") + endif() +endmacro() + +macro(get_child_folders result curdir) + file(GLOB children RELATIVE ${curdir} ${curdir}/*) + set(dirlist "") + foreach(child ${children}) + if(IS_DIRECTORY ${curdir}/${child}) + list(APPEND dirlist ${child}) + endif() + endforeach() + set(${result} ${dirlist}) +endmacro() + +macro(add_plugin_subfolder plugin_folder plugin_enabled_flag) + if (${plugin_enable_flag}) + if (EXISTS "${plugin_folder}/CMakeLists.txt") + add_subdirectory(${plugin_folder}) + endif() + endif() +endmacro() + +macro(link_plugin plugin_name plugin_enable_flag) + if (${plugin_enable_flag}) + if( BUILD_SHARED_LIBS ) + add_dependencies_platform(${PROJECT_NAME} ${plugin_name}) + else() + target_link_libraries(${PROJECT_NAME} ${plugin_name}) + endif() + endif() +endmacro() + +macro(configure_plugin_linking_from_folder plugins_folder) + get_child_folders(PLUGIN_FOLDER_LIST ${plugins_folder}) + foreach(plugin_dir ${PLUGIN_FOLDER_LIST}) + string(TOUPPER ${plugin_dir} plugin_preprocessor_name) + set(plugin_enable_flag "ENGINE_USE_${plugin_preprocessor_name}") + configure_plugin_linking(${plugin_dir} ${plugin_enable_flag}) + endforeach() +endmacro() + +macro(add_plugins_from_folders plugins_folder) + get_child_folders(PLUGIN_FOLDER_LIST ${plugins_folder}) + foreach(plugin_dir ${PLUGIN_FOLDER_LIST}) + string(TOUPPER ${plugin_dir} plugin_preprocessor_name) + set(plugin_enable_flag "ENGINE_USE_${plugin_preprocessor_name}") + add_plugin_subfolder(${plugins_folder}/${plugin_dir} ${plugin_enable_flag}) + endforeach() +endmacro() + +macro(link_plugins_from_folders plugins_folder) + get_child_folders(PLUGIN_FOLDER_LIST ${plugins_folder}) + foreach(plugin_dir ${PLUGIN_FOLDER_LIST}) + string(TOUPPER ${plugin_dir} plugin_preprocessor_name) + set(plugin_enable_flag "ENGINE_USE_${plugin_preprocessor_name}") + link_plugin(${plugin_dir} ${plugin_enable_flag}) + endforeach() +endmacro() diff --git a/cmake/CMakeManifest.cmake b/cmake/CMakeManifest.cmake new file mode 100644 index 0000000..63194c3 --- /dev/null +++ b/cmake/CMakeManifest.cmake @@ -0,0 +1,66 @@ +cmake_minimum_required(VERSION 3.6) + +# Lock the process +file(LOCK "${LOCKDIR}/${OUTFILE}.lock") + +# Set output full file path +set(MANIFEST_FILE "${OUTDIR}/${OUTFILE}") + +# Decode files or directories +if( NOT "${FILENAMES}" STREQUAL "" ) + string(REPLACE "\*" ";" FILENAMES ${FILENAMES}) +elseif( NOT "${DIRNAMES}" STREQUAL "" ) + string(REPLACE "\*" ";" DIRNAMES ${DIRNAMES}) + string(REPLACE "\\" "/" DIRNAMES ${DIRNAMES}) + string(REPLACE "//" "/" DIRNAMES ${DIRNAMES}) + foreach(DIR ${DIRNAMES}) + file(GLOB FILES_IN_DIR "${DIR}/*") + list(APPEND FILENAMES ${FILES_IN_DIR}) + endforeach() +else() + set(FILENAMES) +endif() + +# Loop through all files +foreach(FILENAME ${FILENAMES}) + # Filter out some file by extensions + if( NOT "${FILENAME}" MATCHES ".*(\.exe$|\.dll$)" ) + continue() + endif() + + # Workaround for using correct plugin path + if( NOT "${PLUGIN_DLL_FILEPATH}" STREQUAL "" ) + get_filename_component(A ${FILENAME} NAME) + get_filename_component(B ${PLUGIN_DLL_FILEPATH} NAME) + if( "${A}" STREQUAL "${B}" ) + set(FILENAME "${PLUGIN_DLL_FILEPATH}") + endif() + endif() + + # Get file name only + if( "${FILENAME}" MATCHES "${OUTDIR}" ) + string(REPLACE "${OUTDIR}/" "" FILENAME ${FILENAME}) + else() + get_filename_component(FILENAME ${FILENAME} NAME) + endif() + + # Check if FILENAME is already present in MANIFEST_FILE + set(FOUND 0) + if( EXISTS "${MANIFEST_FILE}" ) + file(STRINGS "${MANIFEST_FILE}" LINES) + foreach(LINE ${LINES}) + if( "${LINE}" MATCHES "${FILENAME}" ) + set(FOUND 1) + break() + endif() + endforeach() + endif() + + # Append FILENAME to MANIFEST_FILE + if( NOT FOUND ) + file(APPEND "${MANIFEST_FILE}" "${FILENAME}\n") + endif() +endforeach() + +# Unlock the process +file(LOCK "${LOCKDIR}/${OUTFILE}.lock" RELEASE) diff --git a/cmake/CMakePlatforms.cmake b/cmake/CMakePlatforms.cmake new file mode 100644 index 0000000..bf55ea5 --- /dev/null +++ b/cmake/CMakePlatforms.cmake @@ -0,0 +1,118 @@ +cmake_minimum_required(VERSION 3.6) + +# This module is shared; use include blocker. +if( _PLATFORMS_ ) + return() +endif() +set(_PLATFORMS_ 1) + +include(CMakeCompiler) + +# Detect target platform +if( ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" ) + set(PLATFORM_WINDOWS 1) + set(PLATFORM_NAME "windows") + if( MSVC_VERSION GREATER 1800 ) + set(REQUIRED_WINDOWSSDK_VERSION 10.0.10586.0) + message(STATUS "Windows SDK version found: ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") + if ( CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION VERSION_LESS REQUIRED_WINDOWSSDK_VERSION ) # Versions before this have serious bugs + message(FATAL_ERROR "Unsupported Windows SDK Version, ${REQUIRED_WINDOWSSDK_VERSION} or greater required") + endif() + endif() + set(PLATFORM_TOOLCHAIN_ENVIRONMENT_ONLY 1) + #include(Toolchain-XBoxOne) + #include(Toolchain-PS4) +elseif( ${CMAKE_SYSTEM_NAME} STREQUAL "WindowsStore" ) + set(PLATFORM_WINUWP 1) + set(PLATFORM_NAME "winuwp") + set(UWP_VERSION_MIN 10.0.14393.0) + set(UWP_VERSION_TARGET 10.0.14393.0) +elseif( ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" ) + if( IOS ) + set(PLATFORM_IOS 1) + set(PLATFORM_NAME "ios") + else() + set(PLATFORM_OSX 1) + set(PLATFORM_NAME "osx") + endif() +elseif( ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" ) + set(PLATFORM_LINUX 1) + set(PLATFORM_NAME "linux") +elseif( ${CMAKE_SYSTEM_NAME} STREQUAL "Android" ) + set(PLATFORM_ANDROID 1) + set(PLATFORM_NAME "android") + set(ENGINE_ANDROID_GLES3 ON CACHE BOOL "Use OpenGL ES 3.0 for Android.") + set(ENGINE_ANDROID_GLES3_GLSL100 OFF CACHE BOOL "Use GLSL 1.0 on OpenGL ES 3.0 for Android.") + set(ENGINE_ANDROID_GL4 OFF CACHE BOOL "Enable OpenGL 4.0 for Android.") # We might want to enable this. (It should work on the K1 chipset.) /aj +elseif( ${CMAKE_SYSTEM_NAME} STREQUAL "Durango" ) + set(PLATFORM_XBOXONE 1) + set(PLATFORM_NAME "xb1") +elseif( ${CMAKE_SYSTEM_NAME} STREQUAL "Orbis" ) + set(PLATFORM_PS4 1) + set(PLATFORM_NAME "ps4") +elseif( ${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten" ) + set(PLATFORM_WEBGL 1) + set(PLATFORM_NAME "webgl") + set(CMAKE_C_FLAGS_DEBUG "" CACHE STRING "" FORCE) + set(CMAKE_CXX_FLAGS_DEBUG "" CACHE STRING "" FORCE) + set(CMAKE_C_FLAGS_DEV "" CACHE STRING "" FORCE) + set(CMAKE_CXX_FLAGS_DEV "" CACHE STRING "" FORCE) + set(CMAKE_C_FLAGS_RELEASE "" CACHE STRING "" FORCE) + set(CMAKE_CXX_FLAGS_RELEASE "" CACHE STRING "" FORCE) + set(CMAKE_EXE_LINKER_FLAGS_DEBUG "" CACHE STRING "" FORCE) + set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "" CACHE STRING "" FORCE) + set(CMAKE_MODULE_LINKER_FLAGS_DEBUG "" CACHE STRING "" FORCE) + set(CMAKE_EXE_LINKER_FLAGS_DEV "" CACHE STRING "" FORCE) + set(CMAKE_SHARED_LINKER_FLAGS_DEV "" CACHE STRING "" FORCE) + set(CMAKE_MODULE_LINKER_FLAGS_DEV "" CACHE STRING "" FORCE) + set(CMAKE_EXE_LINKER_FLAGS_RELEASE "" CACHE STRING "" FORCE) + set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "" CACHE STRING "" FORCE) + set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "" CACHE STRING "" FORCE) +else() + message(FATAL_ERROR "Unknown platform ${CMAKE_SYSTEM_NAME}!") +endif() + +message(STATUS "Detected platform: ${PLATFORM_NAME}") + +# Detect target architecture +if( ((PLATFORM_WINDOWS OR PLATFORM_OSX OR PLATFORM_WINUWP) AND CMAKE_CL_64) OR (PLATFORM_IOS AND CMAKE_OSX_ARCHITECTURES MATCHES "arm64") OR PLATFORM_XBOXONE OR PLATFORM_PS4 OR PLATFORM_LINUX ) + set(PLATFORM_64BIT 1) +endif() + +if( PLATFORM_WINDOWS OR PLATFORM_OSX OR PLATFORM_LINUX OR PLATFORM_XBOXONE OR PLATFORM_PS4 OR PLATFORM_WEBGL OR PLATFORM_WINUWP ) + if( PLATFORM_64BIT ) + set(ARCH_NAME "x64") + else() + set(ARCH_NAME "x86") + endif() +elseif( PLATFORM_IOS OR PLATFORM_ANDROID ) + if( PLATFORM_64BIT ) + set(ARCH_NAME "arm64") + else() + set(ARCH_NAME "arm") + endif() +else() + message(FATAL_ERROR "Unknown platform architecture!") +endif() + +message(STATUS "Detected architecture: ${ARCH_NAME}") + +if( PLATFORM_64BIT ) + set(ARCH_BITS "64") + set(ARCH_64BITS "64") +else() + set(ARCH_BITS "32") + set(ARCH_64BITS "") +endif() + +set(LIB_PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX}) +set(LIB_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX}) + +# Configure CMake global variables +set(CMAKE_INSTALL_MESSAGE LAZY) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin") +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib") +set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib") +if( PLATFORM_WINDOWS ) + set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1) +endif() diff --git a/cmake/CMakeSettings.cmake b/cmake/CMakeSettings.cmake new file mode 100644 index 0000000..240536f --- /dev/null +++ b/cmake/CMakeSettings.cmake @@ -0,0 +1,231 @@ +cmake_minimum_required(VERSION 3.6) + +# This module is shared; use include blocker. +if( _SETTINGS_ ) + return() +endif() +set(_SETTINGS_ 1) + +include(CMakePlatforms) +include(CMakeMacros) + +# Define product build options +set(PRODUCT_NAME "Stingray") +set(PRODUCT_COMPANY "Autodesk") +set(PRODUCT_COPYRIGHT "Copyright (C) 2016 ${PRODUCT_COMPANY}, Inc. All rights reserved.") +set(PRODUCT_VERSION_MAJOR "1") +set(PRODUCT_VERSION_MINOR "8") +set(PRODUCT_VERSION_REVISION "0") + +# Bump this revision if projects require any migration. +# Reset to 0 if you increase MAJOR or MINOR versions. +set(PRODUCT_DEV_VERSION_REVISION "0") + +# Build options controlled by TeamCity - do not change here! +set_default(PRODUCT_VERSION_LABEL "$ENV{SR_PRODUCT_VERSION_LABEL}" "Developer Build") +set_default(PRODUCT_VERSION_TCID "$ENV{SR_PRODUCT_VERSION_TCID}" "0") +set_default(PRODUCT_BUILD_TIMESTAMP "$ENV{SR_PRODUCT_BUILD_TIMESTAMP}" "") +set_default(PRODUCT_LICENSING_KEY "$ENV{SR_PRODUCT_LICENSING_KEY}" "A72I1") +set_default(PRODUCT_LICENSING_VERSION "$ENV{SR_PRODUCT_LICENSING_VERSION}" "2017.0.0.F") +set_default(PRODUCT_EDITOR_STEAM_APPID "$ENV{SR_PRODUCT_EDITOR_STEAM_APPID}" "0") + +# Generate timestamp if not overriden by TeamCity option +if( "${PRODUCT_BUILD_TIMESTAMP}" STREQUAL "" AND NOT "${PRODUCT_VERSION_LABEL}" STREQUAL "Developer Build" ) + string(TIMESTAMP PRODUCT_BUILD_TIMESTAMP "%Y-%m-%dT%H:%M:%SZ" UTC) +endif() + +# Allow environment variables to override some build options +set(ENGINE_BUILD_IDENTIFIER $ENV{SR_BUILD_IDENTIFIER}) + +if( NOT CMAKE_INSTALL_PREFIX OR CMAKE_INSTALL_PREFIX STREQUAL "" ) + message(FATAL_ERROR "CMAKE_INSTALL_PREFIX not set! Please set CMAKE_INSTALL_PREFIX to appropriate location when running this CMake script.") +endif() +string(REGEX REPLACE "\\\\" "/" BINARIES_DIR ${CMAKE_INSTALL_PREFIX}) + +set(ENGINE_LIB_DIR $ENV{SR_LIB_DIR}) +if( NOT ENGINE_LIB_DIR OR ENGINE_LIB_DIR STREQUAL "" ) + message(FATAL_ERROR "Environment variable SR_LIB_DIR not set! Please set environment variable SR_LIB_DIR to appropriate location before running this CMake script.") +endif() +string(REGEX REPLACE "\\\\" "/" ENGINE_LIB_DIR ${ENGINE_LIB_DIR}) + +# Set install directories +if( PLATFORM_WINDOWS ) + set(ENGINE_INSTALL_DIR "${BINARIES_DIR}/engine/win${ARCH_BITS}/$>") +elseif( PLATFORM_WINUWP ) + set(ENGINE_INSTALL_DIR "${BINARIES_DIR}/engine/winuwp${ARCH_BITS}/$>") +else() + set(ENGINE_INSTALL_DIR "${BINARIES_DIR}/engine/${PLATFORM_NAME}/$>") +endif() +set(ENGINE_PLUGINS_INSTALL_DIR "${ENGINE_INSTALL_DIR}/plugins") +set(EDITOR_INSTALL_DIR "${BINARIES_DIR}/editor") +set(TOOLS_INSTALL_DIR "${BINARIES_DIR}/tools") +set(TOOLS_EXTERNAL_INSTALL_DIR "${BINARIES_DIR}/tools_external") + +if( PLATFORM_WINDOWS ) + set(ENGINE_PLUGIN_SUFFIX "w${ARCH_BITS}") +else() + set(ENGINE_PLUGIN_SUFFIX "") +endif() + +# Global options +if( PLATFORM_WINDOWS ) + set(BUILD_SHARED_LIBS ON CACHE BOOL "Build plug-ins as shared libraries.") +else() + set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build plug-ins as static libraries.") +endif() + +if( PLATFORM_IOS ) + set_default(ENGINE_IOS_CODE_SIGN_IDENTITY "$ENV{SR_IOS_CODE_SIGN_IDENTITY}" "iPhone Developer") + set_default(ENGINE_IOS_DEVELOPMENT_TEAM "$ENV{SR_IOS_DEVELOPMENT_TEAM}" "") +endif() + +set(BUILD_RUN_TEST OFF CACHE BOOL "Enable special build for run test mode.") + +# Engine options +set(ENGINE_USE_DEBUG_INFO ON CACHE BOOL "Enable debug information in all configurations.") +set(ENGINE_USE_SOUND ON CACHE BOOL "Enable Sound (Timpani) support.") +set(ENGINE_USE_APEX OFF CACHE BOOL "Enable APEX clothing support.") +set(ENGINE_USE_AVX OFF CACHE BOOL "Enable AVX instructions set support.") +set(ENGINE_USE_UNWRAPLIB ON CACHE BOOL "Enable UV-unwrapping.") +set(ENGINE_USE_STEAM OFF CACHE BOOL "Enable Steamworks support.") +set(ENGINE_USE_STEAM_DEDICATED_SERVER OFF CACHE BOOL "Enable Steamworks dedicated server support.") +set(ENGINE_USE_EXPERIMENTAL_CRITICALSECTIONS OFF CACHE BOOL "Enable experimental spinlocks on Android.") +set(ENGINE_USE_WEBGL_SIMD OFF CACHE BOOL "Enable SIMD support on WebGL.") +set(ENGINE_USE_D3D12 OFF CACHE BOOL "Enable D3D12 support.") + +# Set folder names inside solution files +set(ENGINE_FOLDER_NAME "runtime") +set(ENGINE_PLUGINS_FOLDER_NAME "plugins") +set(ENGINE_USE_SOLUTION_FOLDERS ON) + +# Define if platform can compile game data +if( PLATFORM_64BIT AND (PLATFORM_WINDOWS OR PLATFORM_OSX) ) + set(ENGINE_CAN_COMPILE 1) +endif() + +# Verify configuration validity +if( NOT ENGINE_CAN_COMPILE ) + set(ENGINE_USE_CAPTURE_FRAME_PLUGIN OFF) + set(ENGINE_USE_UNWRAPLIB OFF) + set(ENGINE_USE_TEXTUREREADER_PLUGIN OFF) + set(ENGINE_USE_FBXSDK_PLUGIN OFF) + set(ENGINE_USE_PROTEIN_PLUGIN OFF) + set(ENGINE_USE_XB1_DATA_COMPILER_PLUGIN OFF) + set(ENGINE_USE_PS4_DATA_COMPILER_PLUGIN OFF) +endif() + +if( ENGINE_USE_SOUND AND (PLATFORM_WEBGL OR PLATFORM_WINUWP) ) + message(STATUS "Sound (Timpani) support disabled, unsupported by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_SOUND OFF) +endif() + +if( ENGINE_USE_APEX AND NOT (PLATFORM_WINDOWS OR PLATFORM_XBOXONE OR PLATFORM_PS4) ) + message(STATUS "APEX support disabled, unsupported by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_APEX OFF) +endif() + +if( ENGINE_USE_OCULUS_PLUGIN AND NOT PLATFORM_WINDOWS ) + message(STATUS "Oculus support disabled, unsupported by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_OCULUS_PLUGIN OFF) +endif() + +if( ENGINE_USE_STEAMVR_PLUGIN AND NOT PLATFORM_WINDOWS ) + message(STATUS "SteamVR support disabled, unsupported by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_STEAMVR_PLUGIN OFF) +endif() + +if( ENGINE_USE_GEARVR_PLUGIN AND NOT PLATFORM_ANDROID ) + message(STATUS "GearVR support disabled, unsupported by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_GEARVR_PLUGIN OFF) +endif() + +if( ENGINE_USE_GOOGLEVR_PLUGIN AND NOT (PLATFORM_ANDROID OR PLATFORM_IOS) ) + message(STATUS "GoogleVR support disabled, unsupported by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_GOOGLEVR_PLUGIN OFF) +endif() + +if( ENGINE_USE_GEARVR_PLUGIN AND ENGINE_USE_GOOGLEVR_PLUGIN ) + message(FATAL_ERROR "Cannot enable both GearVR and GoogleVR plug-ins at once.") +endif() + +if( ENGINE_USE_D3D12 AND NOT PLATFORM_WINDOWS ) + message(STATUS "D3D12 support disabled, unsupported by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_D3D12 OFF) +endif() + +if( ENGINE_USE_D3D12 AND MSVC_VERSION LESS 1900 ) + message(FATAL_ERROR "D3D12 requires msvc14 or above.") + set(ENGINE_USE_D3D12 OFF) +endif() + +if( PLATFORM_WEBGL ) + set(ENGINE_USE_HUMANIK_PLUGIN OFF) + message(STATUS "HumanIK plug-in support disabled, not supported yet by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_WWISE_PLUGIN OFF) + message(STATUS "WWise plug-in support disabled, not supported yet by platform ${PLATFORM_NAME}.") +endif() + +if( PLATFORM_WINUWP ) + set(ENGINE_USE_SCALEFORMSTUDIO_PLUGIN OFF) + message(STATUS "Scaleform plug-in support disabled, not supported yet by platform ${PLATFORM_NAME}.") +endif() + +if( PLATFORM_LINUX ) + set(ENGINE_USE_SCALEFORMSTUDIO_PLUGIN OFF) + message(STATUS "Scaleform plug-in support disabled, not supported yet by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_HUMANIK_PLUGIN OFF) + message(STATUS "HumanIK plug-in support disabled, not supported yet by platform ${PLATFORM_NAME}.") + set(ENGINE_USE_WWISE_PLUGIN OFF) + message(STATUS "WWise plug-in support disabled, not supported yet by platform ${PLATFORM_NAME}.") +endif() + +# Editor options +set(EDITOR_SHIPPING OFF CACHE BOOL "Enable editor shipping mode.") +set(EDITOR_USE_STEAM OFF CACHE BOOL "Enable Steamworks support for editor.") +set(EDITOR_USE_CLIC OFF CACHE BOOL "Enable CLIC support.") +set(EDITOR_USE_CER OFF CACHE BOOL "Enable CER support.") +set(EDITOR_USE_UPI OFF CACHE BOOL "Enable UPI support.") +set(EDITOR_USE_MC3 OFF CACHE BOOL "Enable MC3 support.") +set(EDITOR_USE_TEMPLATES OFF CACHE BOOL "Enable editor template install.") +set(EDITOR_USE_GEARVR OFF CACHE BOOL "Enable editor GearVR support.") + +# Verify configuration validity +if( EDITOR_USE_STEAM ) + if( EDITOR_USE_CLIC ) + message(STATUS "CLIC support disabled, implied by editor's steam mode.") + set(EDITOR_USE_CLIC OFF) + endif() +endif() + +if( EDITOR_SHIPPING ) + if( NOT EDITOR_USE_STEAM ) + if( NOT EDITOR_USE_CLIC ) + message(STATUS "CLIC support enabled, implied by editor's shipping mode.") + set(EDITOR_USE_CLIC ON) + endif() + endif() + if( NOT EDITOR_USE_CER ) + message(STATUS "CER support enabled, implied by editor's shipping mode.") + set(EDITOR_USE_CER ON) + endif() + if( NOT EDITOR_USE_UPI ) + message(STATUS "UPI support enabled, implied by editor's shipping mode.") + set(EDITOR_USE_UPI ON) + endif() + if( NOT EDITOR_USE_MC3 ) + message(STATUS "MC3 support enabled, implied by editor's shipping mode.") + set(EDITOR_USE_MC3 ON) + endif() +endif() + +# Exporter options +set(EXPORTERS_USE_BSI OFF CACHE BOOL "Enable bsi plugins.") +set(EXPORTERS_USE_DCC_LINK ON CACHE BOOL "Enable dcc link plugins.") +set(EXPORTERS_USE_MOTION_BUILDER ON CACHE BOOL "Enable Motion Builder plugins.") +set(EXPORTERS_USE_DCC_LINK_WORKFLOW OFF CACHE BOOL "Enable dcc link workflow application.") + +if( EDITOR_USE_STEAM ) + set(PRODUCT_VERSION_REGKEY "Steam-${PRODUCT_EDITOR_STEAM_APPID}") +else() + set(PRODUCT_VERSION_REGKEY "${PRODUCT_VERSION_MAJOR}.${PRODUCT_VERSION_MINOR}.${PRODUCT_VERSION_TCID}.${PRODUCT_VERSION_REVISION}") +endif() diff --git a/cmake/Toolchain-Android.cmake b/cmake/Toolchain-Android.cmake new file mode 100644 index 0000000..41704df --- /dev/null +++ b/cmake/Toolchain-Android.cmake @@ -0,0 +1,49 @@ +# This module is shared; use include blocker. +if( _ANDROID_TOOLCHAIN_ ) + return() +endif() +set(_ANDROID_TOOLCHAIN_ 1) + +# Android Nsight Tegra version requirement +set(REQUIRED_NSIGHT_TEGRA_VERSION "3.4") + +# Get Android Nsight Tegra environment +set(NSIGHT_TEGRA_VERSION ${CMAKE_VS_NsightTegra_VERSION}) +if( "${NSIGHT_TEGRA_VERSION}" STREQUAL "" ) + get_filename_component(NSIGHT_TEGRA_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\NVIDIA Corporation\\Nsight Tegra;Version]" NAME) +endif() + +# Report and check version if it exist +if( NOT "${NSIGHT_TEGRA_VERSION}" STREQUAL "" ) + message(STATUS "Android Nsight Tegra version found: ${NSIGHT_TEGRA_VERSION}") + if( NOT "${NSIGHT_TEGRA_VERSION}" MATCHES "${REQUIRED_NSIGHT_TEGRA_VERSION}+" ) + message(WARNING "Expected Android Nsight Tegra version: ${REQUIRED_NSIGHT_TEGRA_VERSION}") + endif() +endif() + +# We are building Android platform, fail if Android Nsight Tegra not found +if( NOT NSIGHT_TEGRA_VERSION ) + message(FATAL_ERROR "Engine requires Android Nsight Tegra to be installed in order to build Android platform.") +endif() + +# Tell CMake we are cross-compiling to Android +set(CMAKE_SYSTEM_NAME Android) + +# Tell CMake we want to use default Clang NDK toolchain version +set(CMAKE_GENERATOR_TOOLSET DefaultClang) + +# Tell CMake which version of the Android API we are targeting +set(CMAKE_ANDROID_API_MIN 21) +set(CMAKE_ANDROID_API 25) + +# Tell CMake we want to use all CPUs when we build +set(CMAKE_ANDROID_PROCESS_MAX $ENV{NUMBER_OF_PROCESSORS}) + +# Tell CMake we don't want to skip Ant step +set(CMAKE_ANDROID_SKIP_ANT_STEP 0) + +# Tell CMake we have our java source in the 'java' directory +set(CMAKE_ANDROID_JAVA_SOURCE_DIR java) + +# Tell CMake we have use Gradle as our default build system +set(CMAKE_ANDROID_BUILD_SYSTEM GradleBuild) diff --git a/cmake/Toolchain-iOS.cmake b/cmake/Toolchain-iOS.cmake new file mode 100644 index 0000000..f38e916 --- /dev/null +++ b/cmake/Toolchain-iOS.cmake @@ -0,0 +1,104 @@ +# Tell CMake we are cross-compiling to iOS +set(CMAKE_SYSTEM_NAME Darwin) +set(CMAKE_SYSTEM_VERSION 1) +set(UNIX True) +set(APPLE True) +set(IOS True) + +# Set compilers to the Apple Clang +set(CMAKE_C_COMPILER "/usr/bin/clang") +set(CMAKE_CXX_COMPILER "/usr/bin/clang++") + +# Force compilers to skip detecting compiler ABI info and compile features +set(CMAKE_C_COMPILER_FORCED True) +set(CMAKE_CXX_COMPILER_FORCED True) +set(CMAKE_ASM_COMPILER_FORCED True) + +# All iOS/Darwin specific settings - some may be redundant +set(CMAKE_SHARED_LIBRARY_PREFIX "lib") +set(CMAKE_SHARED_LIBRARY_SUFFIX ".dylib") +set(CMAKE_SHARED_MODULE_PREFIX "lib") +set(CMAKE_SHARED_MODULE_SUFFIX ".so") +set(CMAKE_MODULE_EXISTS 1) +set(CMAKE_DL_LIBS "") + +set(CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ") +set(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ") +set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}") +set(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}") + +# Hidden visibility is required for CXX on iOS +set(CMAKE_C_FLAGS_INIT "") +set(CMAKE_CXX_FLAGS_INIT "-fvisibility=hidden -fvisibility-inlines-hidden") + +set(CMAKE_C_LINK_FLAGS "-Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}") +set(CMAKE_CXX_LINK_FLAGS "-Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}") + +set(CMAKE_PLATFORM_HAS_INSTALLNAME 1) +set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib") +set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle") +set(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,") +set(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,") +set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a") + +# hack: if a new cmake (which uses CMAKE_INSTALL_NAME_TOOL) runs on an old build tree +# (where install_name_tool was hardcoded) and where CMAKE_INSTALL_NAME_TOOL isn't in the cache +# and still cmake didn't fail in CMakeFindBinUtils.cmake (because it isn't rerun) +# hardcode CMAKE_INSTALL_NAME_TOOL here to install_name_tool, so it behaves as it did before, Alex +if( NOT DEFINED CMAKE_INSTALL_NAME_TOOL ) + find_program(CMAKE_INSTALL_NAME_TOOL install_name_tool) +endif() + +# Setup iOS platform +if( NOT DEFINED CMAKE_IOS_PLATFORM ) + set(CMAKE_IOS_PLATFORM "OS") +endif() +set(CMAKE_IOS_PLATFORM ${CMAKE_IOS_PLATFORM} CACHE STRING "Type of iOS platform.") +set_property(CACHE CMAKE_IOS_PLATFORM PROPERTY STRINGS OS Simulator) + +# Check the platform selection and setup for developer root +set(CMAKE_IOS_PLATFORM_LOCATION "iPhone${CMAKE_IOS_PLATFORM}.platform") + +# Setup iOS developer location +if( NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT ) + set(CMAKE_IOS_DEVELOPER_ROOT "/Applications/Xcode.app/Contents/Developer/Platforms/${CMAKE_IOS_PLATFORM_LOCATION}/Developer") +endif(NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT) + +# Find and use the most recent iOS sdk +if( NOT DEFINED CMAKE_IOS_SDK_ROOT ) + file(GLOB _CMAKE_IOS_SDKS "${CMAKE_IOS_DEVELOPER_ROOT}/SDKs/*") + if( _CMAKE_IOS_SDKS ) + list(SORT _CMAKE_IOS_SDKS) + list(REVERSE _CMAKE_IOS_SDKS) + list(GET _CMAKE_IOS_SDKS 0 CMAKE_IOS_SDK_ROOT) + else() + message(FATAL_ERROR "No iOS SDK's found in default seach path ${CMAKE_IOS_DEVELOPER_ROOT}. Manually set CMAKE_IOS_SDK_ROOT or install the iOS SDK.") + endif() +endif() + +# Set the sysroot default to the most recent SDK +set(CMAKE_OSX_SYSROOT ${CMAKE_IOS_SDK_ROOT}) + +# Set the target architectures for iOS, separated by a space +set(CMAKE_OSX_ARCHITECTURES "arm64" CACHE string "iOS architecture deployment target.") + +# Set iOS deployment target version +set(CMAKE_IOS_DEPLOYMENT_TARGET "9.0" CACHE string "iOS deployment target version (using latest iOS SDK regardless).") + +# Set the find root to the iOS developer roots and to user defined paths +set(CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_IOS_SDK_ROOT} ${CMAKE_PREFIX_PATH} CACHE string "iOS find search path root.") + +# Default to searching for frameworks first +set(CMAKE_FIND_FRAMEWORK FIRST) + +# Set up the default search directories for frameworks +set(CMAKE_SYSTEM_FRAMEWORK_PATH + ${CMAKE_IOS_SDK_ROOT}/System/Library/Frameworks + ${CMAKE_IOS_SDK_ROOT}/System/Library/PrivateFrameworks + ${CMAKE_IOS_SDK_ROOT}/Developer/Library/Frameworks +) + +# Only search the iOS SDK, not the remainder of the host file system +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/stb_shared.c b/stb_shared.c new file mode 100644 index 0000000..78debee --- /dev/null +++ b/stb_shared.c @@ -0,0 +1,9 @@ +#define STB_IMAGE_IMPLEMENTATION +#define STB_IMAGE_WRITE_IMPLEMENTATION +#define STBI_ONLY_PNG +#define STBI_ONLY_JPEG +#define STBI_ONLY_BMP +#define STBI_ONLY_GIF + +#include "stb_image.h" +#include "stb_image_write.h"