diff options
Diffstat (limited to 'extern/draco/dracoenc/cmake')
21 files changed, 765 insertions, 0 deletions
diff --git a/extern/draco/dracoenc/cmake/DracoConfig.cmake b/extern/draco/dracoenc/cmake/DracoConfig.cmake new file mode 100644 index 00000000000..be5e1faefe2 --- /dev/null +++ b/extern/draco/dracoenc/cmake/DracoConfig.cmake @@ -0,0 +1,3 @@ +@PACKAGE_INIT@ +set_and_check(draco_INCLUDE_DIR "@PACKAGE_draco_include_install_dir@") +set_and_check(draco_LIBRARY_DIR "@PACKAGE_draco_lib_install_dir@") diff --git a/extern/draco/dracoenc/cmake/FindDraco.cmake b/extern/draco/dracoenc/cmake/FindDraco.cmake new file mode 100644 index 00000000000..5f27bf29390 --- /dev/null +++ b/extern/draco/dracoenc/cmake/FindDraco.cmake @@ -0,0 +1,58 @@ +# Finddraco +# +# Locates draco and sets the following variables: +# +# draco_FOUND +# draco_INCLUDE_DIRS +# draco_LIBARY_DIRS +# draco_LIBRARIES +# draco_VERSION_STRING +# +# draco_FOUND is set to YES only when all other variables are successfully +# configured. + +unset(draco_FOUND) +unset(draco_INCLUDE_DIRS) +unset(draco_LIBRARY_DIRS) +unset(draco_LIBRARIES) +unset(draco_VERSION_STRING) + +mark_as_advanced(draco_FOUND) +mark_as_advanced(draco_INCLUDE_DIRS) +mark_as_advanced(draco_LIBRARY_DIRS) +mark_as_advanced(draco_LIBRARIES) +mark_as_advanced(draco_VERSION_STRING) + +set(draco_version_file_no_prefix "draco/src/draco/core/draco_version.h") + +# Set draco_INCLUDE_DIRS +find_path(draco_INCLUDE_DIRS NAMES "${draco_version_file_no_prefix}") + +# Extract the version string from draco_version.h. +if (draco_INCLUDE_DIRS) + set(draco_version_file + "${draco_INCLUDE_DIRS}/draco/src/draco/core/draco_version.h") + file(STRINGS "${draco_version_file}" draco_version + REGEX "kdracoVersion") + list(GET draco_version 0 draco_version) + string(REPLACE "static const char kdracoVersion[] = " "" draco_version + "${draco_version}") + string(REPLACE ";" "" draco_version "${draco_version}") + string(REPLACE "\"" "" draco_version "${draco_version}") + set(draco_VERSION_STRING ${draco_version}) +endif () + +# Find the library. +if (BUILD_SHARED_LIBS) + find_library(draco_LIBRARIES NAMES draco.dll libdraco.dylib libdraco.so) +else () + find_library(draco_LIBRARIES NAMES draco.lib libdraco.a) +endif () + +# Store path to library. +get_filename_component(draco_LIBRARY_DIRS ${draco_LIBRARIES} DIRECTORY) + +if (draco_INCLUDE_DIRS AND draco_LIBRARY_DIRS AND draco_LIBRARIES AND + draco_VERSION_STRING) + set(draco_FOUND YES) +endif () diff --git a/extern/draco/dracoenc/cmake/compiler_flags.cmake b/extern/draco/dracoenc/cmake/compiler_flags.cmake new file mode 100644 index 00000000000..d842a8ab1f4 --- /dev/null +++ b/extern/draco/dracoenc/cmake/compiler_flags.cmake @@ -0,0 +1,216 @@ +if (NOT DRACO_CMAKE_COMPILER_FLAGS_CMAKE_) +set(DRACO_CMAKE_COMPILER_FLAGS_CMAKE_ 1) + +include(CheckCCompilerFlag) +include(CheckCXXCompilerFlag) +include("${draco_root}/cmake/compiler_tests.cmake") + +# Strings used to cache failed C/CXX flags. +set(DRACO_FAILED_C_FLAGS) +set(DRACO_FAILED_CXX_FLAGS) + +# Checks C compiler for support of $c_flag. Adds $c_flag to $CMAKE_C_FLAGS when +# the compile test passes. Caches $c_flag in $DRACO_FAILED_C_FLAGS when the test +# fails. +macro (add_c_flag_if_supported c_flag) + unset(C_FLAG_FOUND CACHE) + string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND) + unset(C_FLAG_FAILED CACHE) + string(FIND "${DRACO_FAILED_C_FLAGS}" "${c_flag}" C_FLAG_FAILED) + + if (${C_FLAG_FOUND} EQUAL -1 AND ${C_FLAG_FAILED} EQUAL -1) + unset(C_FLAG_SUPPORTED CACHE) + message("Checking C compiler flag support for: " ${c_flag}) + check_c_compiler_flag("${c_flag}" C_FLAG_SUPPORTED) + if (${C_FLAG_SUPPORTED}) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${c_flag}" CACHE STRING "") + else () + set(DRACO_FAILED_C_FLAGS "${DRACO_FAILED_C_FLAGS} ${c_flag}" CACHE STRING + "" FORCE) + endif () + endif () +endmacro () + +# Checks C++ compiler for support of $cxx_flag. Adds $cxx_flag to +# $CMAKE_CXX_FLAGS when the compile test passes. Caches $c_flag in +# $DRACO_FAILED_CXX_FLAGS when the test fails. +macro (add_cxx_flag_if_supported cxx_flag) + unset(CXX_FLAG_FOUND CACHE) + string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND) + unset(CXX_FLAG_FAILED CACHE) + string(FIND "${DRACO_FAILED_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FAILED) + + if (${CXX_FLAG_FOUND} EQUAL -1 AND ${CXX_FLAG_FAILED} EQUAL -1) + unset(CXX_FLAG_SUPPORTED CACHE) + message("Checking CXX compiler flag support for: " ${cxx_flag}) + check_cxx_compiler_flag("${cxx_flag}" CXX_FLAG_SUPPORTED) + if (${CXX_FLAG_SUPPORTED}) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_flag}" CACHE STRING "") + else() + set(DRACO_FAILED_CXX_FLAGS "${DRACO_FAILED_CXX_FLAGS} ${cxx_flag}" CACHE + STRING "" FORCE) + endif () + endif () +endmacro () + +# Convenience method for adding a flag to both the C and C++ compiler command +# lines. +macro (add_compiler_flag_if_supported flag) + add_c_flag_if_supported(${flag}) + add_cxx_flag_if_supported(${flag}) +endmacro () + +# Checks C compiler for support of $c_flag and terminates generation when +# support is not present. +macro (require_c_flag c_flag update_c_flags) + unset(C_FLAG_FOUND CACHE) + string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND) + + if (${C_FLAG_FOUND} EQUAL -1) + unset(HAVE_C_FLAG CACHE) + message("Checking C compiler flag support for: " ${c_flag}) + check_c_compiler_flag("${c_flag}" HAVE_C_FLAG) + if (NOT ${HAVE_C_FLAG}) + message(FATAL_ERROR + "${PROJECT_NAME} requires support for C flag: ${c_flag}.") + endif () + if (${update_c_flags}) + set(CMAKE_C_FLAGS "${c_flag} ${CMAKE_C_FLAGS}" CACHE STRING "" FORCE) + endif () + endif () +endmacro () + +# Checks CXX compiler for support of $cxx_flag and terminates generation when +# support is not present. +macro (require_cxx_flag cxx_flag update_cxx_flags) + unset(CXX_FLAG_FOUND CACHE) + string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND) + + if (${CXX_FLAG_FOUND} EQUAL -1) + unset(HAVE_CXX_FLAG CACHE) + message("Checking CXX compiler flag support for: " ${cxx_flag}) + check_cxx_compiler_flag("${cxx_flag}" HAVE_CXX_FLAG) + if (NOT ${HAVE_CXX_FLAG}) + message(FATAL_ERROR + "${PROJECT_NAME} requires support for CXX flag: ${cxx_flag}.") + endif () + if (${update_cxx_flags}) + set(CMAKE_CXX_FLAGS "${cxx_flag} ${CMAKE_CXX_FLAGS}" CACHE STRING "" + FORCE) + endif () + endif () +endmacro () + +# Checks for support of $flag by both the C and CXX compilers. Terminates +# generation when support is not present in both compilers. +macro (require_compiler_flag flag update_cmake_flags) + require_c_flag(${flag} ${update_cmake_flags}) + require_cxx_flag(${flag} ${update_cmake_flags}) +endmacro () + +# Checks only non-MSVC targets for support of $c_flag and terminates generation +# when support is not present. +macro (require_c_flag_nomsvc c_flag update_c_flags) + if (NOT MSVC) + require_c_flag(${c_flag} ${update_c_flags}) + endif () +endmacro () + +# Checks only non-MSVC targets for support of $cxx_flag and terminates +# generation when support is not present. +macro (require_cxx_flag_nomsvc cxx_flag update_cxx_flags) + if (NOT MSVC) + require_cxx_flag(${cxx_flag} ${update_cxx_flags}) + endif () +endmacro () + +# Checks only non-MSVC targets for support of $flag by both the C and CXX +# compilers. Terminates generation when support is not present in both +# compilers. +macro (require_compiler_flag_nomsvc flag update_cmake_flags) + require_c_flag_nomsvc(${flag} ${update_cmake_flags}) + require_cxx_flag_nomsvc(${flag} ${update_cmake_flags}) +endmacro () + +# Adds $flag to assembler command line. +macro (append_as_flag flag) + unset(AS_FLAG_FOUND CACHE) + string(FIND "${DRACO_AS_FLAGS}" "${flag}" AS_FLAG_FOUND) + + if (${AS_FLAG_FOUND} EQUAL -1) + set(DRACO_AS_FLAGS "${DRACO_AS_FLAGS} ${flag}") + endif () +endmacro () + +# Adds $flag to the C compiler command line. +macro (append_c_flag flag) + unset(C_FLAG_FOUND CACHE) + string(FIND "${CMAKE_C_FLAGS}" "${flag}" C_FLAG_FOUND) + + if (${C_FLAG_FOUND} EQUAL -1) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}") + endif () +endmacro () + +# Adds $flag to the CXX compiler command line. +macro (append_cxx_flag flag) + unset(CXX_FLAG_FOUND CACHE) + string(FIND "${CMAKE_CXX_FLAGS}" "${flag}" CXX_FLAG_FOUND) + + if (${CXX_FLAG_FOUND} EQUAL -1) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") + endif () +endmacro () + +# Adds $flag to the C and CXX compiler command lines. +macro (append_compiler_flag flag) + append_c_flag(${flag}) + append_cxx_flag(${flag}) +endmacro () + +# Adds $flag to the executable linker command line. +macro (append_exe_linker_flag flag) + unset(LINKER_FLAG_FOUND CACHE) + string(FIND "${CMAKE_EXE_LINKER_FLAGS}" "${flag}" LINKER_FLAG_FOUND) + + if (${LINKER_FLAG_FOUND} EQUAL -1) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}") + endif () +endmacro () + +# Adds $flag to the link flags for $target. +function (append_link_flag_to_target target flags) + unset(target_link_flags) + get_target_property(target_link_flags ${target} LINK_FLAGS) + + if (target_link_flags) + unset(link_flag_found) + string(FIND "${target_link_flags}" "${flags}" link_flag_found) + + if (NOT ${link_flag_found} EQUAL -1) + return() + endif () + + set(target_link_flags "${target_link_flags} ${flags}") + else () + set(target_link_flags "${flags}") + endif () + + set_target_properties(${target} PROPERTIES LINK_FLAGS ${target_link_flags}) +endfunction () + +# Adds $flag to executable linker flags, and makes sure C/CXX builds still work. +macro (require_linker_flag flag) + append_exe_linker_flag(${flag}) + + unset(c_passed) + draco_check_c_compiles("LINKER_FLAG_C_TEST(${flag})" "" c_passed) + unset(cxx_passed) + draco_check_cxx_compiles("LINKER_FLAG_CXX_TEST(${flag})" "" cxx_passed) + + if (NOT c_passed OR NOT cxx_passed) + message(FATAL_ERROR "Linker flag test for ${flag} failed.") + endif () +endmacro () + +endif () # DRACO_CMAKE_COMPILER_FLAGS_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/compiler_tests.cmake b/extern/draco/dracoenc/cmake/compiler_tests.cmake new file mode 100644 index 00000000000..e529ba11253 --- /dev/null +++ b/extern/draco/dracoenc/cmake/compiler_tests.cmake @@ -0,0 +1,124 @@ +if (NOT DRACO_CMAKE_COMPILER_TESTS_CMAKE_) +set(DRACO_CMAKE_COMPILER_TESTS_CMAKE_ 1) + +include(CheckCSourceCompiles) +include(CheckCXXSourceCompiles) + +# The basic main() macro used in all compile tests. +set(DRACO_C_MAIN "\nint main(void) { return 0; }") +set(DRACO_CXX_MAIN "\nint main() { return 0; }") + +# Strings containing the names of passed and failed tests. +set(DRACO_C_PASSED_TESTS) +set(DRACO_C_FAILED_TESTS) +set(DRACO_CXX_PASSED_TESTS) +set(DRACO_CXX_FAILED_TESTS) + +macro(draco_push_var var new_value) + set(SAVED_${var} ${var}) + set(${var} ${new_value}) +endmacro () + +macro(draco_pop_var var) + set(var ${SAVED_${var}}) + unset(SAVED_${var}) +endmacro () + +# Confirms $test_source compiles and stores $test_name in one of +# $DRACO_C_PASSED_TESTS or $DRACO_C_FAILED_TESTS depending on out come. When the +# test passes $result_var is set to 1. When it fails $result_var is unset. +# The test is not run if the test name is found in either of the passed or +# failed test variables. +macro(draco_check_c_compiles test_name test_source result_var) + unset(C_TEST_PASSED CACHE) + unset(C_TEST_FAILED CACHE) + string(FIND "${DRACO_C_PASSED_TESTS}" "${test_name}" C_TEST_PASSED) + string(FIND "${DRACO_C_FAILED_TESTS}" "${test_name}" C_TEST_FAILED) + if (${C_TEST_PASSED} EQUAL -1 AND ${C_TEST_FAILED} EQUAL -1) + unset(C_TEST_COMPILED CACHE) + message("Running C compiler test: ${test_name}") + check_c_source_compiles("${test_source} ${DRACO_C_MAIN}" C_TEST_COMPILED) + set(${result_var} ${C_TEST_COMPILED}) + + if (${C_TEST_COMPILED}) + set(DRACO_C_PASSED_TESTS "${DRACO_C_PASSED_TESTS} ${test_name}") + else () + set(DRACO_C_FAILED_TESTS "${DRACO_C_FAILED_TESTS} ${test_name}") + message("C Compiler test ${test_name} failed.") + endif () + elseif (NOT ${C_TEST_PASSED} EQUAL -1) + set(${result_var} 1) + else () # ${C_TEST_FAILED} NOT EQUAL -1 + unset(${result_var}) + endif () +endmacro () + +# Confirms $test_source compiles and stores $test_name in one of +# $DRACO_CXX_PASSED_TESTS or $DRACO_CXX_FAILED_TESTS depending on out come. When +# the test passes $result_var is set to 1. When it fails $result_var is unset. +# The test is not run if the test name is found in either of the passed or +# failed test variables. +macro(draco_check_cxx_compiles test_name test_source result_var) + unset(CXX_TEST_PASSED CACHE) + unset(CXX_TEST_FAILED CACHE) + string(FIND "${DRACO_CXX_PASSED_TESTS}" "${test_name}" CXX_TEST_PASSED) + string(FIND "${DRACO_CXX_FAILED_TESTS}" "${test_name}" CXX_TEST_FAILED) + if (${CXX_TEST_PASSED} EQUAL -1 AND ${CXX_TEST_FAILED} EQUAL -1) + unset(CXX_TEST_COMPILED CACHE) + message("Running CXX compiler test: ${test_name}") + check_cxx_source_compiles("${test_source} ${DRACO_CXX_MAIN}" + CXX_TEST_COMPILED) + set(${result_var} ${CXX_TEST_COMPILED}) + + if (${CXX_TEST_COMPILED}) + set(DRACO_CXX_PASSED_TESTS "${DRACO_CXX_PASSED_TESTS} ${test_name}") + else () + set(DRACO_CXX_FAILED_TESTS "${DRACO_CXX_FAILED_TESTS} ${test_name}") + message("CXX Compiler test ${test_name} failed.") + endif () + elseif (NOT ${CXX_TEST_PASSED} EQUAL -1) + set(${result_var} 1) + else () # ${CXX_TEST_FAILED} NOT EQUAL -1 + unset(${result_var}) + endif () +endmacro () + +# Convenience macro that confirms $test_source compiles as C and C++. +# $result_var is set to 1 when both tests are successful, and 0 when one or both +# tests fail. +# Note: This macro is intended to be used to write to result variables that +# are expanded via configure_file(). $result_var is set to 1 or 0 to allow +# direct usage of the value in generated source files. +macro(draco_check_source_compiles test_name test_source result_var) + unset(C_PASSED) + unset(CXX_PASSED) + draco_check_c_compiles(${test_name} ${test_source} C_PASSED) + draco_check_cxx_compiles(${test_name} ${test_source} CXX_PASSED) + if (${C_PASSED} AND ${CXX_PASSED}) + set(${result_var} 1) + else () + set(${result_var} 0) + endif () +endmacro () + +# When inline support is detected for the current compiler the supported +# inlining keyword is written to $result in caller scope. +macro (draco_get_inline result) + draco_check_source_compiles("inline_check_1" + "static inline void macro(void) {}" + HAVE_INLINE_1) + if (HAVE_INLINE_1 EQUAL 1) + set(${result} "inline") + return() + endif () + + # Check __inline. + draco_check_source_compiles("inline_check_2" + "static __inline void macro(void) {}" + HAVE_INLINE_2) + if (HAVE_INLINE_2 EQUAL 1) + set(${result} "__inline") + endif () +endmacro () + +endif () # DRACO_CMAKE_COMPILER_TESTS_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/draco_features.cmake b/extern/draco/dracoenc/cmake/draco_features.cmake new file mode 100644 index 00000000000..057b0b07ecd --- /dev/null +++ b/extern/draco/dracoenc/cmake/draco_features.cmake @@ -0,0 +1,57 @@ +if (NOT DRACO_CMAKE_DRACO_FEATURES_CMAKE_) +set(DRACO_CMAKE_DRACO_FEATURES_CMAKE_ 1) + +set(draco_features_file_name "${draco_build_dir}/draco/draco_features.h") +set(draco_features_list) + +# Macro that handles tracking of Draco preprocessor symbols for the purpose of +# producing draco_features.h. +# +# draco_enable_feature(FEATURE <feature_name> [TARGETS <target_name>]) +# FEATURE is required. It should be a Draco preprocessor symbol. +# TARGETS is optional. It can be one or more draco targets. +# +# When the TARGETS argument is not present the preproc symbol is added to +# draco_features.h. When it is draco_features.h is unchanged, and +# target_compile_options() is called for each target specified. +macro (draco_enable_feature) + set(def_flags) + set(def_single_arg_opts FEATURE) + set(def_multi_arg_opts TARGETS) + cmake_parse_arguments(DEF "${def_flags}" "${def_single_arg_opts}" + "${def_multi_arg_opts}" ${ARGN}) + if ("${DEF_FEATURE}" STREQUAL "") + message(FATAL_ERROR "Empty FEATURE passed to draco_enable_feature().") + endif () + + # Do nothing/return early if $DEF_FEATURE is already in the list. + list(FIND draco_features_list ${DEF_FEATURE} df_index) + if (NOT df_index EQUAL -1) + return () + endif () + + list(LENGTH DEF_TARGETS df_targets_list_length) + if (${df_targets_list_length} EQUAL 0) + list(APPEND draco_features_list ${DEF_FEATURE}) + else () + foreach (target ${DEF_TARGETS}) + target_compile_definitions(${target} PRIVATE ${DEF_FEATURE}) + endforeach () + endif () +endmacro () + +# Function for generating draco_features.h. +function (draco_generate_features_h) + file(WRITE "${draco_features_file_name}" + "// GENERATED FILE -- DO NOT EDIT\n\n" + "#ifndef DRACO_FEATURES_H_\n" + "#define DRACO_FEATURES_H_\n\n") + + foreach (feature ${draco_features_list}) + file(APPEND "${draco_features_file_name}" "#define ${feature}\n") + endforeach () + + file(APPEND "${draco_features_file_name}" "\n#endif // DRACO_FEATURES_H_") +endfunction () + +endif () # DRACO_CMAKE_DRACO_FEATURES_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/draco_test_config.h.cmake b/extern/draco/dracoenc/cmake/draco_test_config.h.cmake new file mode 100644 index 00000000000..77a574123fd --- /dev/null +++ b/extern/draco/dracoenc/cmake/draco_test_config.h.cmake @@ -0,0 +1,13 @@ +#ifndef DRACO_TESTING_DRACO_TEST_CONFIG_H_ +#define DRACO_TESTING_DRACO_TEST_CONFIG_H_ + +// If this file is named draco_test_config.h.cmake: +// This file is used as input at cmake generation time. + +// If this file is named draco_test_config.h: +// GENERATED FILE, DO NOT EDIT. SEE ABOVE. + +#define DRACO_TEST_DATA_DIR "${DRACO_TEST_DATA_DIR}" +#define DRACO_TEST_TEMP_DIR "${DRACO_TEST_TEMP_DIR}" + +#endif // DRACO_TESTING_DRACO_TEST_CONFIG_H_ diff --git a/extern/draco/dracoenc/cmake/draco_version.cc.cmake b/extern/draco/dracoenc/cmake/draco_version.cc.cmake new file mode 100644 index 00000000000..921df7de77d --- /dev/null +++ b/extern/draco/dracoenc/cmake/draco_version.cc.cmake @@ -0,0 +1,21 @@ +// If this file is named draco_version.cc.cmake: +// This file is used as input at cmake generation time. + +// If this file is named draco_version.cc: +// GENERATED FILE, DO NOT EDIT. SEE ABOVE. +#include "draco_version.h" + +static const char kDracoGitHash[] = "${draco_git_hash}"; +static const char kDracoGitDesc[] = "${draco_git_desc}"; + +const char *draco_git_hash() { + return kDracoGitHash; +} + +const char *draco_git_version() { + return kDracoGitDesc; +} + +const char* draco_version() { + return draco::Version(); +} diff --git a/extern/draco/dracoenc/cmake/draco_version.h.cmake b/extern/draco/dracoenc/cmake/draco_version.h.cmake new file mode 100644 index 00000000000..506423ed34c --- /dev/null +++ b/extern/draco/dracoenc/cmake/draco_version.h.cmake @@ -0,0 +1,21 @@ +// If this file is named draco_version.h.cmake: +// This file is used as input at cmake generation time. + +// If this file is named draco_version.h: +// GENERATED FILE, DO NOT EDIT. SEE ABOVE. +#ifndef DRACO_DRACO_VERSION_H_ +#define DRACO_DRACO_VERSION_H_ + +#include "draco/core/draco_version.h" + +// Returns git hash of Draco git repository. +const char *draco_git_hash(); + +// Returns the output of the git describe command when run from the Draco git +// repository. +const char *draco_git_version(); + +// Returns the version string from core/draco_version.h. +const char* draco_version(); + +#endif // DRACO_DRACO_VERSION_H_ diff --git a/extern/draco/dracoenc/cmake/msvc_runtime.cmake b/extern/draco/dracoenc/cmake/msvc_runtime.cmake new file mode 100644 index 00000000000..ca8de08f9a2 --- /dev/null +++ b/extern/draco/dracoenc/cmake/msvc_runtime.cmake @@ -0,0 +1,14 @@ +cmake_minimum_required(VERSION 3.2) + +if (MSVC) + # Use statically linked versions of the MS standard libraries. + if (NOT "${MSVC_RUNTIME}" STREQUAL "dll") + foreach (flag_var + CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE + CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) + if (${flag_var} MATCHES "/MD") + string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}") + endif () + endforeach () + endif () +endif () diff --git a/extern/draco/dracoenc/cmake/sanitizers.cmake b/extern/draco/dracoenc/cmake/sanitizers.cmake new file mode 100644 index 00000000000..e966cd85d52 --- /dev/null +++ b/extern/draco/dracoenc/cmake/sanitizers.cmake @@ -0,0 +1,19 @@ +if (NOT DRACO_CMAKE_SANITIZERS_CMAKE_) +set(DRACO_CMAKE_SANITIZERS_CMAKE_ 1) + +if (MSVC OR NOT SANITIZE) + return () +endif () + +include("${draco_root}/cmake/compiler_flags.cmake") + +string(TOLOWER ${SANITIZE} SANITIZE) + +# Require the sanitizer requested. +require_linker_flag("-fsanitize=${SANITIZE}") +require_compiler_flag("-fsanitize=${SANITIZE}" YES) + +# Make callstacks accurate. +require_compiler_flag("-fno-omit-frame-pointer -fno-optimize-sibling-calls" YES) + +endif() # DRACO_CMAKE_SANITIZERS_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/arm-ios-common.cmake b/extern/draco/dracoenc/cmake/toolchains/arm-ios-common.cmake new file mode 100644 index 00000000000..48f5ce5e68c --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/arm-ios-common.cmake @@ -0,0 +1,13 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARM_IOS_COMMON_CMAKE_) +set(DRACO_CMAKE_ARM_IOS_COMMON_CMAKE_ 1) + +set(CMAKE_SYSTEM_NAME "Darwin") +set(CMAKE_OSX_SYSROOT iphoneos) +set(CMAKE_C_COMPILER clang) +set(CMAKE_C_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}") +set(CMAKE_CXX_COMPILER clang++) +set(CMAKE_CXX_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}") + +# TODO(tomfinegan): Handle bit code embedding. + +endif () # DRACO_CMAKE_TOOLCHAINS_ARM_IOS_COMMON_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/arm64-android-ndk-libcpp.cmake b/extern/draco/dracoenc/cmake/toolchains/arm64-android-ndk-libcpp.cmake new file mode 100644 index 00000000000..bd044199063 --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/arm64-android-ndk-libcpp.cmake @@ -0,0 +1,12 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_ 1) + +include("${CMAKE_CURRENT_LIST_DIR}/../util.cmake") + +set(CMAKE_SYSTEM_NAME Android) +set(CMAKE_ANDROID_ARCH_ABI arm64-v8a) +require_variable(CMAKE_ANDROID_NDK) +set_variable_if_unset(CMAKE_SYSTEM_VERSION 21) +set_variable_if_unset(CMAKE_ANDROID_STL_TYPE c++_static) + +endif () # DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/arm64-ios.cmake b/extern/draco/dracoenc/cmake/toolchains/arm64-ios.cmake new file mode 100644 index 00000000000..0d4909e1be3 --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/arm64-ios.cmake @@ -0,0 +1,14 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_ 1) + +if (XCODE) + # TODO(tomfinegan): Handle arm builds in Xcode. + message(FATAL_ERROR "This toolchain does not support Xcode.") +endif () + +set(CMAKE_SYSTEM_PROCESSOR "arm64") +set(CMAKE_OSX_ARCHITECTURES "arm64") + +include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake") + +endif () # DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/arm64-linux-gcc.cmake b/extern/draco/dracoenc/cmake/toolchains/arm64-linux-gcc.cmake new file mode 100644 index 00000000000..3bab482855c --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/arm64-linux-gcc.cmake @@ -0,0 +1,18 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_ 1) + +set(CMAKE_SYSTEM_NAME "Linux") + +if ("${CROSS}" STREQUAL "") + # Default the cross compiler prefix to something known to work. + set(CROSS aarch64-linux-gnu-) +endif () + +set(CMAKE_C_COMPILER ${CROSS}gcc) +set(CMAKE_CXX_COMPILER ${CROSS}g++) +set(AS_EXECUTABLE ${CROSS}as) +set(CMAKE_C_COMPILER_ARG1 "-march=armv8-a") +set(CMAKE_CXX_COMPILER_ARG1 "-march=armv8-a") +set(CMAKE_SYSTEM_PROCESSOR "arm64") + +endif () # DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/armv7-android-ndk-libcpp.cmake b/extern/draco/dracoenc/cmake/toolchains/armv7-android-ndk-libcpp.cmake new file mode 100644 index 00000000000..fd50defd82e --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/armv7-android-ndk-libcpp.cmake @@ -0,0 +1,12 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_ 1) + +include("${CMAKE_CURRENT_LIST_DIR}/../util.cmake") + +set(CMAKE_SYSTEM_NAME Android) +set(CMAKE_ANDROID_ARCH_ABI armeabi-v7a) +require_variable(CMAKE_ANDROID_NDK) +set_variable_if_unset(CMAKE_SYSTEM_VERSION 18) +set_variable_if_unset(CMAKE_ANDROID_STL_TYPE c++_static) + +endif () # DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/armv7-ios.cmake b/extern/draco/dracoenc/cmake/toolchains/armv7-ios.cmake new file mode 100644 index 00000000000..61d67872917 --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/armv7-ios.cmake @@ -0,0 +1,14 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_ 1) + +if (XCODE) + # TODO(tomfinegan): Handle arm builds in Xcode. + message(FATAL_ERROR "This toolchain does not support Xcode.") +endif () + +set(CMAKE_SYSTEM_PROCESSOR "armv7") +set(CMAKE_OSX_ARCHITECTURES "armv7") + +include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake") + +endif () # DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/armv7-linux-gcc.cmake b/extern/draco/dracoenc/cmake/toolchains/armv7-linux-gcc.cmake new file mode 100644 index 00000000000..e0f850f4270 --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/armv7-linux-gcc.cmake @@ -0,0 +1,24 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_ 1) + +set(CMAKE_SYSTEM_NAME "Linux") + +if ("${CROSS}" STREQUAL "") + # Default the cross compiler prefix to something known to work. + set(CROSS arm-linux-gnueabihf-) +endif () + +if (NOT ${CROSS} MATCHES hf-$) + set(DRACO_EXTRA_TOOLCHAIN_FLAGS "-mfloat-abi=softfp") +endif () + +set(CMAKE_C_COMPILER ${CROSS}gcc) +set(CMAKE_CXX_COMPILER ${CROSS}g++) +set(AS_EXECUTABLE ${CROSS}as) +set(CMAKE_C_COMPILER_ARG1 + "-march=armv7-a -mfpu=neon ${DRACO_EXTRA_TOOLCHAIN_FLAGS}") +set(CMAKE_CXX_COMPILER_ARG1 + "-march=armv7-a -mfpu=neon ${DRACO_EXTRA_TOOLCHAIN_FLAGS}") +set(CMAKE_SYSTEM_PROCESSOR "armv7") + +endif () # DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/armv7s-ios.cmake b/extern/draco/dracoenc/cmake/toolchains/armv7s-ios.cmake new file mode 100644 index 00000000000..45097936bcb --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/armv7s-ios.cmake @@ -0,0 +1,14 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_ 1) + +if (XCODE) + # TODO(tomfinegan): Handle arm builds in Xcode. + message(FATAL_ERROR "This toolchain does not support Xcode.") +endif () + +set(CMAKE_SYSTEM_PROCESSOR "armv7s") +set(CMAKE_OSX_ARCHITECTURES "armv7s") + +include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake") + +endif () # DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/x86-android-ndk-libcpp.cmake b/extern/draco/dracoenc/cmake/toolchains/x86-android-ndk-libcpp.cmake new file mode 100644 index 00000000000..7bb3717971f --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/x86-android-ndk-libcpp.cmake @@ -0,0 +1,12 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_ 1) + +include("${CMAKE_CURRENT_LIST_DIR}/../util.cmake") + +set(CMAKE_SYSTEM_NAME Android) +set(CMAKE_ANDROID_ARCH_ABI x86) +require_variable(CMAKE_ANDROID_NDK) +set_variable_if_unset(CMAKE_SYSTEM_VERSION 18) +set_variable_if_unset(CMAKE_ANDROID_STL_TYPE c++_static) + +endif () # DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/toolchains/x86_64-android-ndk-libcpp.cmake b/extern/draco/dracoenc/cmake/toolchains/x86_64-android-ndk-libcpp.cmake new file mode 100644 index 00000000000..3b86b9d6682 --- /dev/null +++ b/extern/draco/dracoenc/cmake/toolchains/x86_64-android-ndk-libcpp.cmake @@ -0,0 +1,12 @@ +if (NOT DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_) +set(DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_ 1) + +include("${CMAKE_CURRENT_LIST_DIR}/../util.cmake") + +set(CMAKE_SYSTEM_NAME Android) +set(CMAKE_ANDROID_ARCH_ABI x86_64) +require_variable(CMAKE_ANDROID_NDK) +set_variable_if_unset(CMAKE_SYSTEM_VERSION 21) +set_variable_if_unset(CMAKE_ANDROID_STL_TYPE c++_static) + +endif () # DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_ diff --git a/extern/draco/dracoenc/cmake/util.cmake b/extern/draco/dracoenc/cmake/util.cmake new file mode 100644 index 00000000000..252761fe6fb --- /dev/null +++ b/extern/draco/dracoenc/cmake/util.cmake @@ -0,0 +1,74 @@ +if (NOT DRACO_CMAKE_UTIL_CMAKE_) +set(DRACO_CMAKE_UTIL_CMAKE_ 1) + +# Creates dummy source file in $draco_build_dir named $basename.$extension and +# returns the full path to the dummy source file via the $out_file_path +# parameter. +function (create_dummy_source_file basename extension out_file_path) + set(dummy_source_file "${draco_build_dir}/${basename}.${extension}") + file(WRITE "${dummy_source_file}" + "// Generated file. DO NOT EDIT!\n" + "// ${target_name} needs a ${extension} file to force link language, \n" + "// or to silence a harmless CMake warning: Ignore me.\n" + "void ${target_name}_dummy_function(void) {}\n") + set(${out_file_path} ${dummy_source_file} PARENT_SCOPE) +endfunction () + +# Convenience function for adding a dummy source file to $target_name using +# $extension as the file extension. Wraps create_dummy_source_file(). +function (add_dummy_source_file_to_target target_name extension) + create_dummy_source_file("${target_name}" "${extension}" "dummy_source_file") + target_sources(${target_name} PRIVATE ${dummy_source_file}) +endfunction () + +# Extracts the version number from $version_file and returns it to the user via +# $version_string_out_var. This is achieved by finding the first instance of +# the kDracoVersion variable and then removing everything but the string literal +# assigned to the variable. Quotes and semicolon are stripped from the returned +# string. +function (extract_version_string version_file version_string_out_var) + file(STRINGS "${version_file}" draco_version REGEX "kDracoVersion") + list(GET draco_version 0 draco_version) + string(REPLACE "static const char kDracoVersion[] = " "" draco_version + "${draco_version}") + string(REPLACE ";" "" draco_version "${draco_version}") + string(REPLACE "\"" "" draco_version "${draco_version}") + set("${version_string_out_var}" "${draco_version}" PARENT_SCOPE) +endfunction () + +# Sets CMake compiler launcher to $launcher_name when $launcher_name is found in +# $PATH. Warns user about ignoring build flag $launcher_flag when $launcher_name +# is not found in $PATH. +function (set_compiler_launcher launcher_flag launcher_name) + find_program(launcher_path "${launcher_name}") + if (launcher_path) + set(CMAKE_C_COMPILER_LAUNCHER "${launcher_path}" PARENT_SCOPE) + set(CMAKE_CXX_COMPILER_LAUNCHER "${launcher_path}" PARENT_SCOPE) + message("--- Using ${launcher_name} as compiler launcher.") + else () + message(WARNING + "--- Cannot find ${launcher_name}, ${launcher_flag} ignored.") + endif () +endfunction () + +# Terminates CMake execution when $var_name is unset in the environment. Sets +# CMake variable to the value of the environment variable when the variable is +# present in the environment. +macro(require_variable var_name) + if ("$ENV{${var_name}}" STREQUAL "") + message(FATAL_ERROR "${var_name} must be set in environment.") + endif () + set_variable_if_unset(${var_name} "") +endmacro () + +# Sets $var_name to $default_value if not already set in the environment. +macro (set_variable_if_unset var_name default_value) + if (NOT "$ENV{${var_name}}" STREQUAL "") + set(${var_name} $ENV{${var_name}}) + else () + set(${var_name} ${default_value}) + endif () +endmacro () + +endif() # DRACO_CMAKE_UTIL_CMAKE_ + |