summaryrefslogtreecommitdiff
path: root/src/mesh/assimp-master/contrib/draco/cmake
diff options
context:
space:
mode:
authorsanine <sanine.not@pm.me>2022-03-04 10:47:15 -0600
committersanine <sanine.not@pm.me>2022-03-04 10:47:15 -0600
commit058f98a63658dc1a2579826ba167fd61bed1e21f (patch)
treebcba07a1615a14d943f3af3f815a42f3be86b2f3 /src/mesh/assimp-master/contrib/draco/cmake
parent2f8028ac9e0812cb6f3cbb08f0f419e4e717bd22 (diff)
add assimp submodule
Diffstat (limited to 'src/mesh/assimp-master/contrib/draco/cmake')
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/DracoConfig.cmake3
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/FindDraco.cmake56
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/compiler_flags.cmake220
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/compiler_tests.cmake103
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco-config.cmake.template2
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco.pc.template11
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_build_definitions.cmake124
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_cpu_detection.cmake28
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_emscripten.cmake185
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_flags.cmake247
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_helpers.cmake110
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_install.cmake79
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_intrinsics.cmake96
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_options.cmake239
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_sanitizer.cmake32
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_targets.cmake355
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_test_config.h.cmake13
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_tests.cmake133
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/draco_variables.cmake64
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/sanitizers.cmake19
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake14
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/android-ndk-common.cmake23
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/android.cmake39
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-ios-common.cmake17
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake15
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake16
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-ios.cmake14
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake18
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake16
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-ios.cmake14
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake24
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7s-ios.cmake14
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/i386-ios.cmake15
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake16
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake16
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-ios.cmake15
-rw-r--r--src/mesh/assimp-master/contrib/draco/cmake/util.cmake79
37 files changed, 2484 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/DracoConfig.cmake b/src/mesh/assimp-master/contrib/draco/cmake/DracoConfig.cmake
new file mode 100644
index 0000000..be5e1fa
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/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/src/mesh/assimp-master/contrib/draco/cmake/FindDraco.cmake b/src/mesh/assimp-master/contrib/draco/cmake/FindDraco.cmake
new file mode 100644
index 0000000..0a91930
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/FindDraco.cmake
@@ -0,0 +1,56 @@
+# 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/src/mesh/assimp-master/contrib/draco/cmake/compiler_flags.cmake b/src/mesh/assimp-master/contrib/draco/cmake/compiler_flags.cmake
new file mode 100644
index 0000000..8750e6f
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/compiler_flags.cmake
@@ -0,0 +1,220 @@
+if(DRACO_CMAKE_COMPILER_FLAGS_CMAKE_)
+ return()
+endif()
+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()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/compiler_tests.cmake b/src/mesh/assimp-master/contrib/draco/cmake/compiler_tests.cmake
new file mode 100644
index 0000000..e781a65
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/compiler_tests.cmake
@@ -0,0 +1,103 @@
+if(DRACO_CMAKE_COMPILER_TESTS_CMAKE_)
+ return()
+endif()
+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()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco-config.cmake.template b/src/mesh/assimp-master/contrib/draco/cmake/draco-config.cmake.template
new file mode 100644
index 0000000..ca4a456
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco-config.cmake.template
@@ -0,0 +1,2 @@
+set(DRACO_INCLUDE_DIRS "@DRACO_INCLUDE_DIRS@")
+set(DRACO_LIBRARIES "draco")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco.pc.template b/src/mesh/assimp-master/contrib/draco/cmake/draco.pc.template
new file mode 100644
index 0000000..b8ae482
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco.pc.template
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PROJECT_NAME@
+Description: Draco geometry de(com)pression library.
+Version: @DRACO_VERSION@
+Cflags: -I${includedir}
+Libs: -L${libdir} -ldraco
+Libs.private: @CMAKE_THREAD_LIBS_INIT@
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_build_definitions.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_build_definitions.cmake
new file mode 100644
index 0000000..f7354c1
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_build_definitions.cmake
@@ -0,0 +1,124 @@
+if(DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_
+set(DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_ 1)
+
+# Utility for controlling the main draco library dependency. This changes in
+# shared builds, and when an optional target requires a shared library build.
+macro(set_draco_target)
+ if(MSVC)
+ set(draco_dependency draco)
+ set(draco_plugin_dependency ${draco_dependency})
+ else()
+ if(BUILD_SHARED_LIBS)
+ set(draco_dependency draco_shared)
+ else()
+ set(draco_dependency draco_static)
+ endif()
+ set(draco_plugin_dependency draco_static)
+ endif()
+
+ if(BUILD_SHARED_LIBS)
+ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+ endif()
+endmacro()
+
+# Configures flags and sets build system globals.
+macro(draco_set_build_definitions)
+ string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lowercase)
+
+ if(build_type_lowercase MATCHES "rel" AND DRACO_FAST)
+ if(MSVC)
+ list(APPEND draco_msvc_cxx_flags "/Ox")
+ else()
+ list(APPEND draco_base_cxx_flags "-O3")
+ endif()
+ endif()
+
+ draco_load_version_info()
+ set(DRACO_SOVERSION 1)
+
+ list(APPEND draco_include_paths "${draco_root}" "${draco_root}/src"
+ "${draco_build}")
+
+ if(DRACO_ABSL)
+ list(APPEND draco_include_path "${draco_root}/third_party/abseil-cpp")
+ endif()
+
+
+ list(APPEND draco_gtest_include_paths
+ "${draco_root}/../googletest/googlemock/include"
+ "${draco_root}/../googletest/googlemock"
+ "${draco_root}/../googletest/googletest/include"
+ "${draco_root}/../googletest/googletest")
+ list(APPEND draco_test_include_paths ${draco_include_paths}
+ ${draco_gtest_include_paths})
+ list(APPEND draco_defines "DRACO_CMAKE=1"
+ "DRACO_FLAGS_SRCDIR=\"${draco_root}\""
+ "DRACO_FLAGS_TMPDIR=\"/tmp\"")
+
+ if(MSVC OR WIN32)
+ list(APPEND draco_defines "_CRT_SECURE_NO_DEPRECATE=1" "NOMINMAX=1")
+
+ if(BUILD_SHARED_LIBS)
+ set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
+ endif()
+ else()
+ if(${CMAKE_SIZEOF_VOID_P} EQUAL 8)
+ # Ensure 64-bit platforms can support large files.
+ list(APPEND draco_defines "_LARGEFILE_SOURCE" "_FILE_OFFSET_BITS=64")
+ endif()
+ endif()
+
+ if(ANDROID)
+ if(CMAKE_ANDROID_ARCH_ABI STREQUAL "armeabi-v7a")
+ set(CMAKE_ANDROID_ARM_MODE ON)
+ endif()
+ endif()
+
+ set_draco_target()
+
+ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6")
+ # Quiet warnings in copy-list-initialization where {} elision has always
+ # been allowed.
+ list(APPEND draco_clang_cxx_flags "-Wno-missing-braces")
+ endif()
+ endif()
+
+ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "7")
+ if(CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7")
+ # Quiet gcc 6 vs 7 abi warnings:
+ # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77728
+ list(APPEND draco_base_cxx_flags "-Wno-psabi")
+ list(APPEND ABSL_GCC_FLAGS "-Wno-psabi")
+ endif()
+ endif()
+ endif()
+
+ # Source file names ending in these suffixes will have the appropriate
+ # compiler flags added to their compile commands to enable intrinsics.
+ set(draco_neon_source_file_suffix "neon.cc")
+ set(draco_sse4_source_file_suffix "sse4.cc")
+
+ if((${CMAKE_CXX_COMPILER_ID}
+ STREQUAL
+ "GNU"
+ AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 5)
+ OR (${CMAKE_CXX_COMPILER_ID}
+ STREQUAL
+ "Clang"
+ AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 4))
+ message(
+ WARNING "GNU/GCC < v5 or Clang/LLVM < v4, ENABLING COMPATIBILITY MODE.")
+ draco_enable_feature(FEATURE "DRACO_OLD_GCC")
+ endif()
+
+ if(EMSCRIPTEN)
+ draco_check_emscripten_environment()
+ draco_get_required_emscripten_flags(FLAG_LIST_VAR draco_base_cxx_flags)
+ endif()
+
+ draco_configure_sanitizer()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_cpu_detection.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_cpu_detection.cmake
new file mode 100644
index 0000000..96e4a28
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_cpu_detection.cmake
@@ -0,0 +1,28 @@
+if(DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_
+set(DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_ 1)
+
+# Detect optimizations available for the current target CPU.
+macro(draco_optimization_detect)
+ if(DRACO_ENABLE_OPTIMIZATIONS)
+ string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" cpu_lowercase)
+ if(cpu_lowercase MATCHES "^arm|^aarch64")
+ set(draco_have_neon ON)
+ elseif(cpu_lowercase MATCHES "^x86|amd64")
+ set(draco_have_sse4 ON)
+ endif()
+ endif()
+
+ if(draco_have_neon AND DRACO_ENABLE_NEON)
+ list(APPEND draco_defines "DRACO_ENABLE_NEON=1")
+ else()
+ list(APPEND draco_defines "DRACO_ENABLE_NEON=0")
+ endif()
+
+ if(draco_have_sse4 AND DRACO_ENABLE_SSE4_1)
+ list(APPEND draco_defines "DRACO_ENABLE_SSE4_1=1")
+ else()
+ list(APPEND draco_defines "DRACO_ENABLE_SSE4_1=0")
+ endif()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_emscripten.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_emscripten.cmake
new file mode 100644
index 0000000..10c9350
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_emscripten.cmake
@@ -0,0 +1,185 @@
+if(DRACO_CMAKE_DRACO_EMSCRIPTEN_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_EMSCRIPTEN_CMAKE_
+
+# Checks environment for Emscripten prerequisites.
+macro(draco_check_emscripten_environment)
+ if(NOT PYTHONINTERP_FOUND)
+ message(
+ FATAL_ERROR
+ "Python required for Emscripten builds, but cmake cannot find it.")
+ endif()
+ if(NOT EXISTS "$ENV{EMSCRIPTEN}")
+ message(
+ FATAL_ERROR
+ "The EMSCRIPTEN environment variable must be set. See README.md.")
+ endif()
+endmacro()
+
+# Obtains the required Emscripten flags for Draco targets.
+macro(draco_get_required_emscripten_flags)
+ set(em_FLAG_LIST_VAR)
+ set(em_flags)
+ set(em_single_arg_opts FLAG_LIST_VAR)
+ set(em_multi_arg_opts)
+ cmake_parse_arguments(em "${em_flags}" "${em_single_arg_opts}"
+ "${em_multi_arg_opts}" ${ARGN})
+ if(NOT em_FLAG_LIST_VAR)
+ message(FATAL "draco_get_required_emscripten_flags: FLAG_LIST_VAR required")
+ endif()
+
+ if(DRACO_JS_GLUE)
+ unset(required_flags)
+ list(APPEND ${em_FLAG_LIST_VAR} "-sALLOW_MEMORY_GROWTH=1")
+ list(APPEND ${em_FLAG_LIST_VAR} "-Wno-almost-asm")
+ list(APPEND ${em_FLAG_LIST_VAR} "--memory-init-file" "0")
+ list(APPEND ${em_FLAG_LIST_VAR} "-fno-omit-frame-pointer")
+ list(APPEND ${em_FLAG_LIST_VAR} "-sMODULARIZE=1")
+ list(APPEND ${em_FLAG_LIST_VAR} "-sNO_FILESYSTEM=1")
+ list(APPEND ${em_FLAG_LIST_VAR} "-sEXPORTED_RUNTIME_METHODS=[]")
+ list(APPEND ${em_FLAG_LIST_VAR} "-sPRECISE_F32=1")
+ list(APPEND ${em_FLAG_LIST_VAR} "-sNODEJS_CATCH_EXIT=0")
+ list(APPEND ${em_FLAG_LIST_VAR} "-sNODEJS_CATCH_REJECTION=0")
+
+ if(DRACO_FAST)
+ list(APPEND ${em_FLAG_LIST_VAR} "--llvm-lto" "1")
+ endif()
+ if(DRACO_WASM)
+ list(APPEND ${em_FLAG_LIST_VAR} "-sWASM=1")
+ else()
+ list(APPEND ${em_FLAG_LIST_VAR} "-sWASM=0")
+ endif()
+ if(DRACO_IE_COMPATIBLE)
+ list(APPEND ${em_FLAG_LIST_VAR} "-sLEGACY_VM_SUPPORT=1")
+ endif()
+ endif()
+endmacro()
+
+# Macro for generating C++ glue code from IDL for Emscripten targets. Executes
+# python to generate the C++ binding, and establishes dendency: $OUTPUT_PATH.cpp
+# on $INPUT_IDL.
+macro(draco_generate_emscripten_glue)
+ set(glue_flags)
+ set(glue_single_arg_opts INPUT_IDL OUTPUT_PATH)
+ set(glue_multi_arg_opts)
+ cmake_parse_arguments(glue "${glue_flags}" "${glue_single_arg_opts}"
+ "${glue_multi_arg_opts}" ${ARGN})
+
+ if(DRACO_VERBOSE GREATER 1)
+ message("--------- draco_generate_emscripten_glue -----------\n"
+ "glue_INPUT_IDL=${glue_INPUT_IDL}\n"
+ "glue_OUTPUT_PATH=${glue_OUTPUT_PATH}\n" ]
+ "----------------------------------------------------\n")
+ endif()
+
+ if(NOT glue_INPUT_IDL OR NOT glue_OUTPUT_PATH)
+ message(
+ FATAL_ERROR
+ "draco_generate_emscripten_glue: INPUT_IDL and OUTPUT_PATH required.")
+ endif()
+
+ # Generate the glue source.
+ execute_process(COMMAND ${PYTHON_EXECUTABLE}
+ $ENV{EMSCRIPTEN}/tools/webidl_binder.py
+ ${glue_INPUT_IDL} ${glue_OUTPUT_PATH})
+ if(NOT EXISTS "${glue_OUTPUT_PATH}.cpp")
+ message(FATAL_ERROR "JS glue generation failed for ${glue_INPUT_IDL}.")
+ endif()
+
+ # Create a dependency so that it regenerated on edits.
+ add_custom_command(OUTPUT "${glue_OUTPUT_PATH}.cpp"
+ COMMAND ${PYTHON_EXECUTABLE}
+ $ENV{EMSCRIPTEN}/tools/webidl_binder.py
+ ${glue_INPUT_IDL} ${glue_OUTPUT_PATH}
+ DEPENDS ${draco_js_dec_idl}
+ COMMENT "Generating ${glue_OUTPUT_PATH}.cpp."
+ WORKING_DIRECTORY ${draco_build}
+ VERBATIM)
+endmacro()
+
+# Wrapper for draco_add_executable() that handles the extra work necessary for
+# emscripten targets when generating JS glue:
+#
+# ~~~
+# - Set source level dependency on the C++ binding.
+# - Pre/Post link emscripten magic.
+#
+# Required args:
+# - GLUE_PATH: Base path for glue file. Used to generate .cpp and .js files.
+# - PRE_LINK_JS_SOURCES: em_link_pre_js() source files.
+# - POST_LINK_JS_SOURCES: em_link_post_js() source files.
+# Optional args:
+# - FEATURES:
+# ~~~
+macro(draco_add_emscripten_executable)
+ unset(emexe_NAME)
+ unset(emexe_FEATURES)
+ unset(emexe_SOURCES)
+ unset(emexe_DEFINES)
+ unset(emexe_INCLUDES)
+ unset(emexe_LINK_FLAGS)
+ set(optional_args)
+ set(single_value_args NAME GLUE_PATH)
+ set(multi_value_args SOURCES DEFINES FEATURES INCLUDES LINK_FLAGS
+ PRE_LINK_JS_SOURCES POST_LINK_JS_SOURCES)
+
+ cmake_parse_arguments(emexe "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT
+ (emexe_GLUE_PATH
+ AND emexe_POST_LINK_JS_SOURCES
+ AND emexe_PRE_LINK_JS_SOURCES))
+ message(FATAL
+ "draco_add_emscripten_executable: GLUE_PATH PRE_LINK_JS_SOURCES "
+ "POST_LINK_JS_SOURCES args required.")
+ endif()
+
+ if(DRACO_VERBOSE GREATER 1)
+ message("--------- draco_add_emscripten_executable ---------\n"
+ "emexe_NAME=${emexe_NAME}\n"
+ "emexe_SOURCES=${emexe_SOURCES}\n"
+ "emexe_DEFINES=${emexe_DEFINES}\n"
+ "emexe_INCLUDES=${emexe_INCLUDES}\n"
+ "emexe_LINK_FLAGS=${emexe_LINK_FLAGS}\n"
+ "emexe_GLUE_PATH=${emexe_GLUE_PATH}\n"
+ "emexe_FEATURES=${emexe_FEATURES}\n"
+ "emexe_PRE_LINK_JS_SOURCES=${emexe_PRE_LINK_JS_SOURCES}\n"
+ "emexe_POST_LINK_JS_SOURCES=${emexe_POST_LINK_JS_SOURCES}\n"
+ "----------------------------------------------------\n")
+ endif()
+
+ # The Emscripten linker needs the C++ flags in addition to whatever has been
+ # passed in with the target.
+ list(APPEND emexe_LINK_FLAGS ${DRACO_CXX_FLAGS})
+
+ if(DRACO_GLTF)
+ draco_add_executable(NAME
+ ${emexe_NAME}
+ OUTPUT_NAME
+ ${emexe_NAME}_gltf
+ SOURCES
+ ${emexe_SOURCES}
+ DEFINES
+ ${emexe_DEFINES}
+ INCLUDES
+ ${emexe_INCLUDES}
+ LINK_FLAGS
+ ${emexe_LINK_FLAGS})
+ else()
+ draco_add_executable(NAME ${emexe_NAME} SOURCES ${emexe_SOURCES} DEFINES
+ ${emexe_DEFINES} INCLUDES ${emexe_INCLUDES} LINK_FLAGS
+ ${emexe_LINK_FLAGS})
+ endif()
+
+ foreach(feature ${emexe_FEATURES})
+ draco_enable_feature(FEATURE ${feature} TARGETS ${emexe_NAME})
+ endforeach()
+
+ set_property(SOURCE ${emexe_SOURCES}
+ APPEND
+ PROPERTY OBJECT_DEPENDS "${emexe_GLUE_PATH}.cpp")
+ em_link_pre_js(${emexe_NAME} ${emexe_PRE_LINK_JS_SOURCES})
+ em_link_post_js(${emexe_NAME} "${emexe_GLUE_PATH}.js"
+ ${emexe_POST_LINK_JS_SOURCES})
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_flags.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_flags.cmake
new file mode 100644
index 0000000..0397859
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_flags.cmake
@@ -0,0 +1,247 @@
+if(DRACO_CMAKE_DRACO_FLAGS_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_FLAGS_CMAKE_
+set(DRACO_CMAKE_DRACO_FLAGS_CMAKE_ 1)
+
+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
+
+# Adds compiler flags specified by FLAGS to the sources specified by SOURCES:
+#
+# draco_set_compiler_flags_for_sources(SOURCES <sources> FLAGS <flags>)
+macro(draco_set_compiler_flags_for_sources)
+ unset(compiler_SOURCES)
+ unset(compiler_FLAGS)
+ unset(optional_args)
+ unset(single_value_args)
+ set(multi_value_args SOURCES FLAGS)
+ cmake_parse_arguments(compiler "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT (compiler_SOURCES AND compiler_FLAGS))
+ draco_die("draco_set_compiler_flags_for_sources: SOURCES and "
+ "FLAGS required.")
+ endif()
+
+ set_source_files_properties(${compiler_SOURCES} PROPERTIES COMPILE_FLAGS
+ ${compiler_FLAGS})
+
+ if(DRACO_VERBOSE GREATER 1)
+ foreach(source ${compiler_SOURCES})
+ foreach(flag ${compiler_FLAGS})
+ message("draco_set_compiler_flags_for_sources: source:${source} "
+ "flag:${flag}")
+ endforeach()
+ endforeach()
+ endif()
+endmacro()
+
+# Tests compiler flags stored in list(s) specified by FLAG_LIST_VAR_NAMES, adds
+# flags to $DRACO_CXX_FLAGS when tests pass. Terminates configuration if
+# FLAG_REQUIRED is specified and any flag check fails.
+#
+# ~~~
+# draco_test_cxx_flag(<FLAG_LIST_VAR_NAMES <flag list variable(s)>>
+# [FLAG_REQUIRED])
+# ~~~
+macro(draco_test_cxx_flag)
+ unset(cxx_test_FLAG_LIST_VAR_NAMES)
+ unset(cxx_test_FLAG_REQUIRED)
+ unset(single_value_args)
+ set(optional_args FLAG_REQUIRED)
+ set(multi_value_args FLAG_LIST_VAR_NAMES)
+ cmake_parse_arguments(cxx_test "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT cxx_test_FLAG_LIST_VAR_NAMES)
+ draco_die("draco_test_cxx_flag: FLAG_LIST_VAR_NAMES required")
+ endif()
+
+ unset(cxx_flags)
+ foreach(list_var ${cxx_test_FLAG_LIST_VAR_NAMES})
+ if(DRACO_VERBOSE)
+ message("draco_test_cxx_flag: adding ${list_var} to cxx_flags")
+ endif()
+ list(APPEND cxx_flags ${${list_var}})
+ endforeach()
+
+ if(DRACO_VERBOSE)
+ message("CXX test: all flags: ${cxx_flags}")
+ endif()
+
+ unset(all_cxx_flags)
+ list(APPEND all_cxx_flags ${DRACO_CXX_FLAGS} ${cxx_flags})
+
+ # Turn off output from check_cxx_source_compiles. Print status directly
+ # instead since the logging messages from check_cxx_source_compiles can be
+ # quite confusing.
+ set(CMAKE_REQUIRED_QUIET TRUE)
+
+ # Run the actual compile test.
+ unset(draco_all_cxx_flags_pass CACHE)
+ message("--- Running combined CXX flags test, flags: ${all_cxx_flags}")
+
+ # check_cxx_compiler_flag() requires that the flags are a string. When flags
+ # are passed as a list it will remove the list separators, and attempt to run
+ # a compile command using list entries concatenated together as a single
+ # argument. Avoid the problem by forcing the argument to be a string.
+ draco_set_and_stringify(SOURCE_VARS all_cxx_flags DEST all_cxx_flags)
+ check_cxx_compiler_flag("${all_cxx_flags}" draco_all_cxx_flags_pass)
+
+ if(cxx_test_FLAG_REQUIRED AND NOT draco_all_cxx_flags_pass)
+ draco_die("Flag test failed for required flag(s): "
+ "${all_cxx_flags} and FLAG_REQUIRED specified.")
+ endif()
+
+ if(draco_all_cxx_flags_pass)
+ # Test passed: update the global flag list used by the draco target creation
+ # wrappers.
+ set(DRACO_CXX_FLAGS ${cxx_flags})
+ list(REMOVE_DUPLICATES DRACO_CXX_FLAGS)
+
+ if(DRACO_VERBOSE)
+ message("DRACO_CXX_FLAGS=${DRACO_CXX_FLAGS}")
+ endif()
+
+ message("--- Passed combined CXX flags test")
+ else()
+ message("--- Failed combined CXX flags test, testing flags individually.")
+
+ if(cxx_flags)
+ message("--- Testing flags from $cxx_flags: " "${cxx_flags}")
+ foreach(cxx_flag ${cxx_flags})
+ # Since 3.17.0 check_cxx_compiler_flag() sets a normal variable at
+ # parent scope while check_cxx_source_compiles() continues to set an
+ # internal cache variable, so we unset both to avoid the failure /
+ # success state persisting between checks. This has been fixed in newer
+ # CMake releases, but 3.17 is pretty common: we will need this to avoid
+ # weird build breakages while the fix propagates.
+ unset(cxx_flag_test_passed)
+ unset(cxx_flag_test_passed CACHE)
+ message("--- Testing flag: ${cxx_flag}")
+ check_cxx_compiler_flag("${cxx_flag}" cxx_flag_test_passed)
+
+ if(cxx_flag_test_passed)
+ message("--- Passed test for ${cxx_flag}")
+ else()
+ list(REMOVE_ITEM cxx_flags ${cxx_flag})
+ message("--- Failed test for ${cxx_flag}, flag removed.")
+ endif()
+ endforeach()
+
+ set(DRACO_CXX_FLAGS ${cxx_flags})
+ endif()
+ endif()
+
+ if(DRACO_CXX_FLAGS)
+ list(REMOVE_DUPLICATES DRACO_CXX_FLAGS)
+ endif()
+endmacro()
+
+# Tests executable linker flags stored in list specified by FLAG_LIST_VAR_NAME,
+# adds flags to $DRACO_EXE_LINKER_FLAGS when test passes. Terminates
+# configuration when flag check fails. draco_set_cxx_flags() must be called
+# before calling this macro because it assumes $DRACO_CXX_FLAGS contains only
+# valid CXX flags.
+#
+# draco_test_exe_linker_flag(<FLAG_LIST_VAR_NAME <flag list variable)>)
+macro(draco_test_exe_linker_flag)
+ unset(link_FLAG_LIST_VAR_NAME)
+ unset(optional_args)
+ unset(multi_value_args)
+ set(single_value_args FLAG_LIST_VAR_NAME)
+ cmake_parse_arguments(link "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT link_FLAG_LIST_VAR_NAME)
+ draco_die("draco_test_link_flag: FLAG_LIST_VAR_NAME required")
+ endif()
+
+ draco_set_and_stringify(DEST linker_flags SOURCE_VARS
+ ${link_FLAG_LIST_VAR_NAME})
+
+ if(DRACO_VERBOSE)
+ message("EXE LINKER test: all flags: ${linker_flags}")
+ endif()
+
+ # Tests of $DRACO_CXX_FLAGS have already passed. Include them with the linker
+ # test.
+ draco_set_and_stringify(DEST CMAKE_REQUIRED_FLAGS SOURCE_VARS DRACO_CXX_FLAGS)
+
+ # Cache the global exe linker flags.
+ if(CMAKE_EXE_LINKER_FLAGS)
+ set(cached_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS})
+ draco_set_and_stringify(DEST CMAKE_EXE_LINKER_FLAGS SOURCE ${linker_flags})
+ endif()
+
+ draco_set_and_stringify(DEST CMAKE_EXE_LINKER_FLAGS SOURCE ${linker_flags}
+ ${CMAKE_EXE_LINKER_FLAGS})
+
+ # Turn off output from check_cxx_source_compiles. Print status directly
+ # instead since the logging messages from check_cxx_source_compiles can be
+ # quite confusing.
+ set(CMAKE_REQUIRED_QUIET TRUE)
+
+ message("--- Running EXE LINKER test for flags: ${linker_flags}")
+
+ unset(linker_flag_test_passed CACHE)
+ set(draco_cxx_main "\nint main() { return 0; }")
+ check_cxx_source_compiles("${draco_cxx_main}" linker_flag_test_passed)
+
+ if(NOT linker_flag_test_passed)
+ draco_die("EXE LINKER test failed.")
+ endif()
+
+ message("--- Passed EXE LINKER flag test.")
+
+ # Restore cached global exe linker flags.
+ if(cached_CMAKE_EXE_LINKER_FLAGS)
+ set(CMAKE_EXE_LINKER_FLAGS ${cached_CMAKE_EXE_LINKER_FLAGS})
+ else()
+ unset(CMAKE_EXE_LINKER_FLAGS)
+ endif()
+
+ list(APPEND DRACO_EXE_LINKER_FLAGS ${${link_FLAG_LIST_VAR_NAME}})
+ list(REMOVE_DUPLICATES DRACO_EXE_LINKER_FLAGS)
+endmacro()
+
+# Runs the draco compiler tests. This macro builds up the list of list var(s)
+# that is passed to draco_test_cxx_flag().
+#
+# Note: draco_set_build_definitions() must be called before this macro.
+macro(draco_set_cxx_flags)
+ unset(cxx_flag_lists)
+
+ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+ list(APPEND cxx_flag_lists draco_base_cxx_flags)
+ endif()
+
+ # Append clang flags after the base set to allow -Wno* overrides to take
+ # effect. Some of the base flags may enable a large set of warnings, e.g.,
+ # -Wall.
+ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+ list(APPEND cxx_flag_lists draco_clang_cxx_flags)
+ endif()
+
+ if(MSVC)
+ list(APPEND cxx_flag_lists draco_msvc_cxx_flags)
+ endif()
+
+ draco_set_and_stringify(DEST cxx_flags SOURCE_VARS ${cxx_flag_lists})
+ if(DRACO_VERBOSE)
+ message("draco_set_cxx_flags: internal CXX flags: ${cxx_flags}")
+ endif()
+
+ if(DRACO_CXX_FLAGS)
+ list(APPEND cxx_flag_lists DRACO_CXX_FLAGS)
+ if(DRACO_VERBOSE)
+ message("draco_set_cxx_flags: user CXX flags: ${DRACO_CXX_FLAGS}")
+ endif()
+ endif()
+
+ draco_set_and_stringify(DEST cxx_flags SOURCE_VARS ${cxx_flag_lists})
+
+ if(cxx_flags)
+ draco_test_cxx_flag(FLAG_LIST_VAR_NAMES ${cxx_flag_lists})
+ endif()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_helpers.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_helpers.cmake
new file mode 100644
index 0000000..0b3b804
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_helpers.cmake
@@ -0,0 +1,110 @@
+if(DRACO_CMAKE_DRACO_HELPERS_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_HELPERS_CMAKE_
+set(DRACO_CMAKE_DRACO_HELPERS_CMAKE_ 1)
+
+# Kills build generation using message(FATAL_ERROR) and outputs all data passed
+# to the console via use of $ARGN.
+macro(draco_die)
+ message(FATAL_ERROR ${ARGN})
+endmacro()
+
+# Converts semi-colon delimited list variable(s) to string. Output is written to
+# variable supplied via the DEST parameter. Input is from an expanded variable
+# referenced by SOURCE and/or variable(s) referenced by SOURCE_VARS.
+macro(draco_set_and_stringify)
+ set(optional_args)
+ set(single_value_args DEST SOURCE_VAR)
+ set(multi_value_args SOURCE SOURCE_VARS)
+ cmake_parse_arguments(sas "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT sas_DEST OR NOT (sas_SOURCE OR sas_SOURCE_VARS))
+ draco_die("draco_set_and_stringify: DEST and at least one of SOURCE "
+ "SOURCE_VARS required.")
+ endif()
+
+ unset(${sas_DEST})
+
+ if(sas_SOURCE)
+ # $sas_SOURCE is one or more expanded variables, just copy the values to
+ # $sas_DEST.
+ set(${sas_DEST} "${sas_SOURCE}")
+ endif()
+
+ if(sas_SOURCE_VARS)
+ # $sas_SOURCE_VARS is one or more variable names. Each iteration expands a
+ # variable and appends it to $sas_DEST.
+ foreach(source_var ${sas_SOURCE_VARS})
+ set(${sas_DEST} "${${sas_DEST}} ${${source_var}}")
+ endforeach()
+
+ # Because $sas_DEST can be empty when entering this scope leading whitespace
+ # can be introduced to $sas_DEST on the first iteration of the above loop.
+ # Remove it:
+ string(STRIP "${${sas_DEST}}" ${sas_DEST})
+ endif()
+
+ # Lists in CMake are simply semicolon delimited strings, so stringification is
+ # just a find and replace of the semicolon.
+ string(REPLACE ";" " " ${sas_DEST} "${${sas_DEST}}")
+
+ if(DRACO_VERBOSE GREATER 1)
+ message("draco_set_and_stringify: ${sas_DEST}=${${sas_DEST}}")
+ endif()
+endmacro()
+
+# Creates a dummy source file in $DRACO_GENERATED_SOURCES_DIRECTORY and adds it
+# to the specified target. Optionally adds its path to a list variable.
+#
+# draco_create_dummy_source_file(<TARGET <target> BASENAME <basename of file>>
+# [LISTVAR <list variable>])
+macro(draco_create_dummy_source_file)
+ set(optional_args)
+ set(single_value_args TARGET BASENAME LISTVAR)
+ set(multi_value_args)
+ cmake_parse_arguments(cdsf "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT cdsf_TARGET OR NOT cdsf_BASENAME)
+ draco_die("draco_create_dummy_source_file: TARGET and BASENAME required.")
+ endif()
+
+ if(NOT DRACO_GENERATED_SOURCES_DIRECTORY)
+ set(DRACO_GENERATED_SOURCES_DIRECTORY "${draco_build}/gen_src")
+ endif()
+
+ set(dummy_source_dir "${DRACO_GENERATED_SOURCES_DIRECTORY}")
+ set(dummy_source_file
+ "${dummy_source_dir}/draco_${cdsf_TARGET}_${cdsf_BASENAME}.cc")
+ set(dummy_source_code
+ "// Generated file. DO NOT EDIT!\n"
+ "// C++ source file created for target ${cdsf_TARGET}.\n"
+ "void draco_${cdsf_TARGET}_${cdsf_BASENAME}_dummy_function(void)\;\n"
+ "void draco_${cdsf_TARGET}_${cdsf_BASENAME}_dummy_function(void) {}\n")
+ file(WRITE "${dummy_source_file}" ${dummy_source_code})
+
+ target_sources(${cdsf_TARGET} PRIVATE ${dummy_source_file})
+
+ if(cdsf_LISTVAR)
+ list(APPEND ${cdsf_LISTVAR} "${dummy_source_file}")
+ endif()
+endmacro()
+
+# Loads the version string from $draco_source/draco/version.h and sets
+# $DRACO_VERSION.
+macro(draco_load_version_info)
+ file(STRINGS "${draco_src_root}/core/draco_version.h" version_file_strings)
+ foreach(str ${version_file_strings})
+ if(str MATCHES "char kDracoVersion")
+ string(FIND "${str}" "\"" open_quote_pos)
+ string(FIND "${str}" ";" semicolon_pos)
+ math(EXPR open_quote_pos "${open_quote_pos} + 1")
+ math(EXPR close_quote_pos "${semicolon_pos} - 1")
+ math(EXPR version_string_length "${close_quote_pos} - ${open_quote_pos}")
+ string(SUBSTRING "${str}" ${open_quote_pos} ${version_string_length}
+ DRACO_VERSION)
+ break()
+ endif()
+ endforeach()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_install.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_install.cmake
new file mode 100644
index 0000000..09bfb59
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_install.cmake
@@ -0,0 +1,79 @@
+if(DRACO_CMAKE_DRACO_INSTALL_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_INSTALL_CMAKE_
+set(DRACO_CMAKE_DRACO_INSTALL_CMAKE_ 1)
+
+# Sets up the draco install targets. Must be called after the static library
+# target is created.
+macro(draco_setup_install_target)
+ include(GNUInstallDirs)
+
+ # pkg-config: draco.pc
+ set(prefix "${CMAKE_INSTALL_PREFIX}")
+ set(exec_prefix "\${prefix}")
+ set(libdir "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
+ set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+ set(draco_lib_name "draco")
+
+ configure_file("${draco_root}/cmake/draco.pc.template"
+ "${draco_build}/draco.pc" @ONLY NEWLINE_STYLE UNIX)
+ install(FILES "${draco_build}/draco.pc"
+ DESTINATION "${prefix}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+
+ # CMake config: draco-config.cmake
+ set(DRACO_INCLUDE_DIRS "${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+ configure_file("${draco_root}/cmake/draco-config.cmake.template"
+ "${draco_build}/draco-config.cmake" @ONLY NEWLINE_STYLE UNIX)
+ install(
+ FILES "${draco_build}/draco-config.cmake"
+ DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/cmake")
+
+ foreach(file ${draco_sources})
+ if(file MATCHES "h$")
+ list(APPEND draco_api_includes ${file})
+ endif()
+ endforeach()
+
+ # Strip $draco_src_root from the file paths: we need to install relative to
+ # $include_directory.
+ list(TRANSFORM draco_api_includes REPLACE "${draco_src_root}/" "")
+ set(include_directory "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+ foreach(draco_api_include ${draco_api_includes})
+ get_filename_component(file_directory ${draco_api_include} DIRECTORY)
+ set(target_directory "${include_directory}/draco/${file_directory}")
+ install(FILES ${draco_src_root}/${draco_api_include}
+ DESTINATION "${target_directory}")
+ endforeach()
+
+ install(
+ FILES "${draco_build}/draco/draco_features.h"
+ DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/draco/")
+
+ install(TARGETS draco_decoder DESTINATION
+ "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
+ install(TARGETS draco_encoder DESTINATION
+ "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
+
+ if(MSVC)
+ install(TARGETS draco DESTINATION
+ "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+ else()
+ install(TARGETS draco_static DESTINATION
+ "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+ if(BUILD_SHARED_LIBS)
+ install(TARGETS draco_shared DESTINATION
+ "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+ endif()
+ endif()
+
+ if(DRACO_UNITY_PLUGIN)
+ install(TARGETS dracodec_unity DESTINATION
+ "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+ endif()
+ if(DRACO_MAYA_PLUGIN)
+ install(TARGETS draco_maya_wrapper DESTINATION
+ "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+ endif()
+
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_intrinsics.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_intrinsics.cmake
new file mode 100644
index 0000000..9011c0d
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_intrinsics.cmake
@@ -0,0 +1,96 @@
+if(DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_
+set(DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_ 1)
+
+# Returns the compiler flag for the SIMD intrinsics suffix specified by the
+# SUFFIX argument via the variable specified by the VARIABLE argument:
+# draco_get_intrinsics_flag_for_suffix(SUFFIX <suffix> VARIABLE <var name>)
+macro(draco_get_intrinsics_flag_for_suffix)
+ unset(intrinsics_SUFFIX)
+ unset(intrinsics_VARIABLE)
+ unset(optional_args)
+ unset(multi_value_args)
+ set(single_value_args SUFFIX VARIABLE)
+ cmake_parse_arguments(intrinsics "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT (intrinsics_SUFFIX AND intrinsics_VARIABLE))
+ message(FATAL_ERROR "draco_get_intrinsics_flag_for_suffix: SUFFIX and "
+ "VARIABLE required.")
+ endif()
+
+ if(intrinsics_SUFFIX MATCHES "neon")
+ if(NOT MSVC)
+ set(${intrinsics_VARIABLE} "${DRACO_NEON_INTRINSICS_FLAG}")
+ endif()
+ elseif(intrinsics_SUFFIX MATCHES "sse4")
+ if(NOT MSVC)
+ set(${intrinsics_VARIABLE} "-msse4.1")
+ endif()
+ else()
+ message(FATAL_ERROR "draco_get_intrinsics_flag_for_suffix: Unknown "
+ "instrinics suffix: ${intrinsics_SUFFIX}")
+ endif()
+
+ if(DRACO_VERBOSE GREATER 1)
+ message("draco_get_intrinsics_flag_for_suffix: "
+ "suffix:${intrinsics_SUFFIX} flag:${${intrinsics_VARIABLE}}")
+ endif()
+endmacro()
+
+# Processes source files specified by SOURCES and adds intrinsics flags as
+# necessary: draco_process_intrinsics_sources(SOURCES <sources>)
+#
+# Detects requirement for intrinsics flags using source file name suffix.
+# Currently supports only SSE4.1.
+macro(draco_process_intrinsics_sources)
+ unset(arg_TARGET)
+ unset(arg_SOURCES)
+ unset(optional_args)
+ set(single_value_args TARGET)
+ set(multi_value_args SOURCES)
+ cmake_parse_arguments(arg "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+ if(NOT (arg_TARGET AND arg_SOURCES))
+ message(FATAL_ERROR "draco_process_intrinsics_sources: TARGET and "
+ "SOURCES required.")
+ endif()
+
+ if(DRACO_ENABLE_SSE4_1 AND draco_have_sse4)
+ unset(sse4_sources)
+ list(APPEND sse4_sources ${arg_SOURCES})
+
+ list(FILTER sse4_sources INCLUDE REGEX
+ "${draco_sse4_source_file_suffix}$")
+
+ if(sse4_sources)
+ unset(sse4_flags)
+ draco_get_intrinsics_flag_for_suffix(SUFFIX
+ ${draco_sse4_source_file_suffix}
+ VARIABLE sse4_flags)
+ if(sse4_flags)
+ draco_set_compiler_flags_for_sources(SOURCES ${sse4_sources} FLAGS
+ ${sse4_flags})
+ endif()
+ endif()
+ endif()
+
+ if(DRACO_ENABLE_NEON AND draco_have_neon)
+ unset(neon_sources)
+ list(APPEND neon_sources ${arg_SOURCES})
+ list(FILTER neon_sources INCLUDE REGEX
+ "${draco_neon_source_file_suffix}$")
+
+ if(neon_sources AND DRACO_NEON_INTRINSICS_FLAG)
+ unset(neon_flags)
+ draco_get_intrinsics_flag_for_suffix(SUFFIX
+ ${draco_neon_source_file_suffix}
+ VARIABLE neon_flags)
+ if(neon_flags)
+ draco_set_compiler_flags_for_sources(SOURCES ${neon_sources} FLAGS
+ ${neon_flags})
+ endif()
+ endif()
+ endif()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_options.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_options.cmake
new file mode 100644
index 0000000..832bfb6
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_options.cmake
@@ -0,0 +1,239 @@
+if(DRACO_CMAKE_DRACO_OPTIONS_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_OPTIONS_CMAKE_
+set(DRACO_CMAKE_DRACO_OPTIONS_CMAKE_)
+
+set(draco_features_file_name "${draco_build}/draco/draco_features.h")
+set(draco_features_list)
+
+# Simple wrapper for CMake's builtin option command that tracks draco's build
+# options in the list variable $draco_options.
+macro(draco_option)
+ unset(option_NAME)
+ unset(option_HELPSTRING)
+ unset(option_VALUE)
+ unset(optional_args)
+ unset(multi_value_args)
+ set(single_value_args NAME HELPSTRING VALUE)
+ cmake_parse_arguments(option "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(NOT (option_NAME AND option_HELPSTRING AND DEFINED option_VALUE))
+ message(FATAL_ERROR "draco_option: NAME HELPSTRING and VALUE required.")
+ endif()
+
+ option(${option_NAME} ${option_HELPSTRING} ${option_VALUE})
+
+ if(DRACO_VERBOSE GREATER 2)
+ message("--------- draco_option ---------\n" "option_NAME=${option_NAME}\n"
+ "option_HELPSTRING=${option_HELPSTRING}\n"
+ "option_VALUE=${option_VALUE}\n"
+ "------------------------------------------\n")
+ endif()
+
+ list(APPEND draco_options ${option_NAME})
+ list(REMOVE_DUPLICATES draco_options)
+endmacro()
+
+# Dumps the $draco_options list via CMake message command.
+macro(draco_dump_options)
+ foreach(option_name ${draco_options})
+ message("${option_name}: ${${option_name}}")
+ endforeach()
+endmacro()
+
+# Set default options.
+macro(draco_set_default_options)
+ draco_option(NAME DRACO_FAST HELPSTRING "Try to build faster libs." VALUE OFF)
+ draco_option(NAME DRACO_JS_GLUE HELPSTRING
+ "Enable JS Glue and JS targets when using Emscripten." VALUE ON)
+ draco_option(NAME DRACO_IE_COMPATIBLE HELPSTRING
+ "Enable support for older IE builds when using Emscripten." VALUE
+ OFF)
+ draco_option(NAME DRACO_MESH_COMPRESSION HELPSTRING "Enable mesh compression."
+ VALUE ON)
+ draco_option(NAME DRACO_POINT_CLOUD_COMPRESSION HELPSTRING
+ "Enable point cloud compression." VALUE ON)
+ draco_option(NAME DRACO_PREDICTIVE_EDGEBREAKER HELPSTRING
+ "Enable predictive edgebreaker." VALUE ON)
+ draco_option(NAME DRACO_STANDARD_EDGEBREAKER HELPSTRING
+ "Enable stand edgebreaker." VALUE ON)
+ draco_option(NAME DRACO_BACKWARDS_COMPATIBILITY HELPSTRING
+ "Enable backwards compatibility." VALUE ON)
+ draco_option(NAME DRACO_DECODER_ATTRIBUTE_DEDUPLICATION HELPSTRING
+ "Enable attribute deduping." VALUE OFF)
+ draco_option(NAME DRACO_TESTS HELPSTRING "Enables tests." VALUE OFF)
+ draco_option(NAME DRACO_WASM HELPSTRING "Enables WASM support." VALUE OFF)
+ draco_option(NAME DRACO_UNITY_PLUGIN HELPSTRING
+ "Build plugin library for Unity." VALUE OFF)
+ draco_option(NAME DRACO_ANIMATION_ENCODING HELPSTRING "Enable animation."
+ VALUE OFF)
+ draco_option(NAME DRACO_GLTF HELPSTRING "Support GLTF." VALUE OFF)
+ draco_option(NAME DRACO_MAYA_PLUGIN HELPSTRING
+ "Build plugin library for Maya." VALUE OFF)
+ draco_check_deprecated_options()
+endmacro()
+
+# Warns when a deprecated option is used and sets the option that replaced it.
+macro(draco_handle_deprecated_option)
+ unset(option_OLDNAME)
+ unset(option_NEWNAME)
+ unset(optional_args)
+ unset(multi_value_args)
+ set(single_value_args OLDNAME NEWNAME)
+ cmake_parse_arguments(option "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if("${${option_OLDNAME}}")
+ message(WARNING "${option_OLDNAME} is deprecated. Use ${option_NEWNAME}.")
+ set(${option_NEWNAME} ${${option_OLDNAME}})
+ endif()
+endmacro()
+
+# Checks for use of deprecated options.
+macro(draco_check_deprecated_options)
+ draco_handle_deprecated_option(OLDNAME ENABLE_EXTRA_SPEED NEWNAME DRACO_FAST)
+ draco_handle_deprecated_option(OLDNAME ENABLE_JS_GLUE NEWNAME DRACO_JS_GLUE)
+ draco_handle_deprecated_option(OLDNAME ENABLE_MESH_COMPRESSION NEWNAME
+ DRACO_MESH_COMPRESSION)
+ draco_handle_deprecated_option(OLDNAME ENABLE_POINT_CLOUD_COMPRESSION NEWNAME
+ DRACO_POINT_CLOUD_COMPRESSION)
+ draco_handle_deprecated_option(OLDNAME ENABLE_PREDICTIVE_EDGEBREAKER NEWNAME
+ DRACO_PREDICTIVE_EDGEBREAKER)
+ draco_handle_deprecated_option(OLDNAME ENABLE_STANDARD_EDGEBREAKER NEWNAME
+ DRACO_STANDARD_EDGEBREAKER)
+ draco_handle_deprecated_option(OLDNAME ENABLE_BACKWARDS_COMPATIBILITY NEWNAME
+ DRACO_BACKWARDS_COMPATIBILITY)
+ draco_handle_deprecated_option(OLDNAME ENABLE_DECODER_ATTRIBUTE_DEDUPLICATION
+ NEWNAME DRACO_DECODER_ATTRIBUTE_DEDUPLICATION)
+ draco_handle_deprecated_option(OLDNAME ENABLE_TESTS NEWNAME DRACO_TESTS)
+ draco_handle_deprecated_option(OLDNAME ENABLE_WASM NEWNAME DRACO_WASM)
+ draco_handle_deprecated_option(OLDNAME BUILD_UNITY_PLUGIN NEWNAME
+ DRACO_UNITY_PLUGIN)
+ draco_handle_deprecated_option(OLDNAME BUILD_ANIMATION_ENCODING NEWNAME
+ DRACO_ANIMATION_ENCODING)
+ draco_handle_deprecated_option(OLDNAME BUILD_FOR_GLTF NEWNAME DRACO_GLTF)
+ draco_handle_deprecated_option(OLDNAME BUILD_MAYA_PLUGIN NEWNAME
+ DRACO_MAYA_PLUGIN)
+ draco_handle_deprecated_option(OLDNAME BUILD_USD_PLUGIN NEWNAME
+ BUILD_SHARED_LIBS)
+
+endmacro()
+
+# Macro for setting Draco features based on user configuration. Features enabled
+# by this macro are Draco global.
+macro(draco_set_optional_features)
+ if(DRACO_GLTF)
+ # Override settings when building for GLTF.
+ draco_enable_feature(FEATURE "DRACO_MESH_COMPRESSION_SUPPORTED")
+ draco_enable_feature(FEATURE "DRACO_NORMAL_ENCODING_SUPPORTED")
+ draco_enable_feature(FEATURE "DRACO_STANDARD_EDGEBREAKER_SUPPORTED")
+ else()
+ if(DRACO_POINT_CLOUD_COMPRESSION)
+ draco_enable_feature(FEATURE "DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED")
+ endif()
+ if(DRACO_MESH_COMPRESSION)
+ draco_enable_feature(FEATURE "DRACO_MESH_COMPRESSION_SUPPORTED")
+ draco_enable_feature(FEATURE "DRACO_NORMAL_ENCODING_SUPPORTED")
+
+ if(DRACO_STANDARD_EDGEBREAKER)
+ draco_enable_feature(FEATURE "DRACO_STANDARD_EDGEBREAKER_SUPPORTED")
+ endif()
+ if(DRACO_PREDICTIVE_EDGEBREAKER)
+ draco_enable_feature(FEATURE "DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED")
+ endif()
+ endif()
+
+ if(DRACO_BACKWARDS_COMPATIBILITY)
+ draco_enable_feature(FEATURE "DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED")
+ endif()
+
+
+ if(NOT EMSCRIPTEN)
+ # For now, enable deduplication for both encoder and decoder.
+ # TODO(ostava): Support for disabling attribute deduplication for the C++
+ # decoder is planned in future releases.
+ draco_enable_feature(FEATURE
+ DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED)
+ draco_enable_feature(FEATURE
+ DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED)
+ endif()
+ endif()
+
+ if(DRACO_UNITY_PLUGIN)
+ draco_enable_feature(FEATURE "DRACO_UNITY_PLUGIN")
+ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+ endif()
+
+ if(DRACO_MAYA_PLUGIN)
+ draco_enable_feature(FEATURE "DRACO_MAYA_PLUGIN")
+ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+ endif()
+
+endmacro()
+
+# 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}.new"
+ "// 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}.new" "#define ${feature}\n")
+ endforeach()
+
+ file(APPEND "${draco_features_file_name}.new"
+ "\n#endif // DRACO_FEATURES_H_")
+
+ # Will replace ${draco_features_file_name} only if the file content has
+ # changed. This prevents forced Draco rebuilds after CMake runs.
+ configure_file("${draco_features_file_name}.new"
+ "${draco_features_file_name}")
+ file(REMOVE "${draco_features_file_name}.new")
+endfunction()
+
+# Sets default options for the build and processes user controlled options to
+# compute enabled features.
+macro(draco_setup_options)
+ draco_set_default_options()
+ draco_set_optional_features()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_sanitizer.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_sanitizer.cmake
new file mode 100644
index 0000000..d2e41a6
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_sanitizer.cmake
@@ -0,0 +1,32 @@
+if(DRACO_CMAKE_DRACO_SANITIZER_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_SANITIZER_CMAKE_
+set(DRACO_CMAKE_DRACO_SANITIZER_CMAKE_ 1)
+
+# Handles the details of enabling sanitizers.
+macro(draco_configure_sanitizer)
+ if(DRACO_SANITIZE AND NOT EMSCRIPTEN AND NOT MSVC)
+ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+ if(DRACO_SANITIZE MATCHES "cfi")
+ list(APPEND SAN_CXX_FLAGS "-flto" "-fno-sanitize-trap=cfi")
+ list(APPEND SAN_LINKER_FLAGS "-flto" "-fno-sanitize-trap=cfi"
+ "-fuse-ld=gold")
+ endif()
+
+ if(${CMAKE_SIZEOF_VOID_P} EQUAL 4
+ AND DRACO_SANITIZE MATCHES "integer|undefined")
+ list(APPEND SAN_LINKER_FLAGS "--rtlib=compiler-rt" "-lgcc_s")
+ endif()
+ endif()
+
+ list(APPEND SAN_CXX_FLAGS "-fsanitize=${DRACO_SANITIZE}")
+ list(APPEND SAN_LINKER_FLAGS "-fsanitize=${DRACO_SANITIZE}")
+
+ # Make sanitizer callstacks accurate.
+ list(APPEND SAN_CXX_FLAGS "-fno-omit-frame-pointer")
+ list(APPEND SAN_CXX_FLAGS "-fno-optimize-sibling-calls")
+
+ draco_test_cxx_flag(FLAG_LIST_VAR_NAMES SAN_CXX_FLAGS FLAG_REQUIRED)
+ draco_test_exe_linker_flag(FLAG_LIST_VAR_NAME SAN_LINKER_FLAGS)
+ endif()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_targets.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_targets.cmake
new file mode 100644
index 0000000..0456c4d
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_targets.cmake
@@ -0,0 +1,355 @@
+if(DRACO_CMAKE_DRACO_TARGETS_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_TARGETS_CMAKE_
+set(DRACO_CMAKE_DRACO_TARGETS_CMAKE_ 1)
+
+# Resets list variables used to track draco targets.
+macro(draco_reset_target_lists)
+ unset(draco_targets)
+ unset(draco_exe_targets)
+ unset(draco_lib_targets)
+ unset(draco_objlib_targets)
+ unset(draco_module_targets)
+ unset(draco_sources)
+ unset(draco_test_targets)
+endmacro()
+
+# Creates an executable target. The target name is passed as a parameter to the
+# NAME argument, and the sources passed as a parameter to the SOURCES argument:
+# draco_add_executable(NAME <name> SOURCES <sources> [optional args])
+#
+# Optional args:
+# cmake-format: off
+# - OUTPUT_NAME: Override output file basename. Target basename defaults to
+# NAME.
+# - TEST: Flag. Presence means treat executable as a test.
+# - DEFINES: List of preprocessor macro definitions.
+# - INCLUDES: list of include directories for the target.
+# - COMPILE_FLAGS: list of compiler flags for the target.
+# - LINK_FLAGS: List of linker flags for the target.
+# - OBJLIB_DEPS: List of CMake object library target dependencies.
+# - LIB_DEPS: List of CMake library dependencies.
+# cmake-format: on
+#
+# Sources passed to this macro are added to $draco_test_sources when TEST is
+# specified. Otherwise sources are added to $draco_sources.
+#
+# Targets passed to this macro are always added to the $draco_targets list. When
+# TEST is specified targets are also added to the $draco_test_targets list.
+# Otherwise targets are added to $draco_exe_targets.
+macro(draco_add_executable)
+ unset(exe_TEST)
+ unset(exe_TEST_DEFINES_MAIN)
+ unset(exe_NAME)
+ unset(exe_OUTPUT_NAME)
+ unset(exe_SOURCES)
+ unset(exe_DEFINES)
+ unset(exe_INCLUDES)
+ unset(exe_COMPILE_FLAGS)
+ unset(exe_LINK_FLAGS)
+ unset(exe_OBJLIB_DEPS)
+ unset(exe_LIB_DEPS)
+ set(optional_args TEST)
+ set(single_value_args NAME OUTPUT_NAME)
+ set(multi_value_args SOURCES DEFINES INCLUDES COMPILE_FLAGS LINK_FLAGS
+ OBJLIB_DEPS LIB_DEPS)
+
+ cmake_parse_arguments(exe "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(DRACO_VERBOSE GREATER 1)
+ message("--------- draco_add_executable ---------\n"
+ "exe_TEST=${exe_TEST}\n"
+ "exe_TEST_DEFINES_MAIN=${exe_TEST_DEFINES_MAIN}\n"
+ "exe_NAME=${exe_NAME}\n"
+ "exe_OUTPUT_NAME=${exe_OUTPUT_NAME}\n"
+ "exe_SOURCES=${exe_SOURCES}\n"
+ "exe_DEFINES=${exe_DEFINES}\n"
+ "exe_INCLUDES=${exe_INCLUDES}\n"
+ "exe_COMPILE_FLAGS=${exe_COMPILE_FLAGS}\n"
+ "exe_LINK_FLAGS=${exe_LINK_FLAGS}\n"
+ "exe_OBJLIB_DEPS=${exe_OBJLIB_DEPS}\n"
+ "exe_LIB_DEPS=${exe_LIB_DEPS}\n"
+ "------------------------------------------\n")
+ endif()
+
+ if(NOT (exe_NAME AND exe_SOURCES))
+ message(FATAL_ERROR "draco_add_executable: NAME and SOURCES required.")
+ endif()
+
+ list(APPEND draco_targets ${exe_NAME})
+ if(exe_TEST)
+ list(APPEND draco_test_targets ${exe_NAME})
+ list(APPEND draco_test_sources ${exe_SOURCES})
+ else()
+ list(APPEND draco_exe_targets ${exe_NAME})
+ list(APPEND draco_sources ${exe_SOURCES})
+ endif()
+
+ add_executable(${exe_NAME} ${exe_SOURCES})
+ set_target_properties(${exe_NAME} PROPERTIES VERSION ${DRACO_VERSION})
+
+ if(exe_OUTPUT_NAME)
+ set_target_properties(${exe_NAME} PROPERTIES OUTPUT_NAME ${exe_OUTPUT_NAME})
+ endif()
+
+ draco_process_intrinsics_sources(TARGET ${exe_NAME} SOURCES ${exe_SOURCES})
+
+ if(exe_DEFINES)
+ target_compile_definitions(${exe_NAME} PRIVATE ${exe_DEFINES})
+ endif()
+
+ if(exe_INCLUDES)
+ target_include_directories(${exe_NAME} PRIVATE ${exe_INCLUDES})
+ endif()
+
+ if(exe_COMPILE_FLAGS OR DRACO_CXX_FLAGS)
+ target_compile_options(${exe_NAME}
+ PRIVATE ${exe_COMPILE_FLAGS} ${DRACO_CXX_FLAGS})
+ endif()
+
+ if(exe_LINK_FLAGS OR DRACO_EXE_LINKER_FLAGS)
+ if(${CMAKE_VERSION} VERSION_LESS "3.13")
+ list(APPEND exe_LINK_FLAGS "${DRACO_EXE_LINKER_FLAGS}")
+ # LINK_FLAGS is managed as a string.
+ draco_set_and_stringify(SOURCE "${exe_LINK_FLAGS}" DEST exe_LINK_FLAGS)
+ set_target_properties(${exe_NAME}
+ PROPERTIES LINK_FLAGS "${exe_LINK_FLAGS}")
+ else()
+ target_link_options(${exe_NAME} PRIVATE ${exe_LINK_FLAGS}
+ ${DRACO_EXE_LINKER_FLAGS})
+ endif()
+ endif()
+
+ if(exe_OBJLIB_DEPS)
+ foreach(objlib_dep ${exe_OBJLIB_DEPS})
+ target_sources(${exe_NAME} PRIVATE $<TARGET_OBJECTS:${objlib_dep}>)
+ endforeach()
+ endif()
+
+ if(CMAKE_THREAD_LIBS_INIT)
+ list(APPEND exe_LIB_DEPS ${CMAKE_THREAD_LIBS_INIT})
+ endif()
+
+ if(BUILD_SHARED_LIBS AND (MSVC OR WIN32))
+ target_compile_definitions(${exe_NAME} PRIVATE "DRACO_BUILDING_DLL=0")
+ endif()
+
+ if(exe_LIB_DEPS)
+ unset(exe_static)
+ if("${CMAKE_EXE_LINKER_FLAGS} ${DRACO_EXE_LINKER_FLAGS}" MATCHES "static")
+ set(exe_static ON)
+ endif()
+
+ if(exe_static AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+ # Third party dependencies can introduce dependencies on system and test
+ # libraries. Since the target created here is an executable, and CMake
+ # does not provide a method of controlling order of link dependencies,
+ # wrap all of the dependencies of this target in start/end group flags to
+ # ensure that dependencies of third party targets can be resolved when
+ # those dependencies happen to be resolved by dependencies of the current
+ # target.
+ list(INSERT exe_LIB_DEPS 0 -Wl,--start-group)
+ list(APPEND exe_LIB_DEPS -Wl,--end-group)
+ endif()
+ target_link_libraries(${exe_NAME} PRIVATE ${exe_LIB_DEPS})
+ endif()
+endmacro()
+
+# Creates a library target of the specified type. The target name is passed as a
+# parameter to the NAME argument, the type as a parameter to the TYPE argument,
+# and the sources passed as a parameter to the SOURCES argument:
+# draco_add_library(NAME <name> TYPE <type> SOURCES <sources> [optional args])
+#
+# Optional args:
+# cmake-format: off
+# - OUTPUT_NAME: Override output file basename. Target basename defaults to
+# NAME. OUTPUT_NAME is ignored when BUILD_SHARED_LIBS is enabled and CMake
+# is generating a build for which MSVC is true. This is to avoid output
+# basename collisions with DLL import libraries.
+# - TEST: Flag. Presence means treat library as a test.
+# - DEFINES: List of preprocessor macro definitions.
+# - INCLUDES: list of include directories for the target.
+# - COMPILE_FLAGS: list of compiler flags for the target.
+# - LINK_FLAGS: List of linker flags for the target.
+# - OBJLIB_DEPS: List of CMake object library target dependencies.
+# - LIB_DEPS: List of CMake library dependencies.
+# - PUBLIC_INCLUDES: List of include paths to export to dependents.
+# cmake-format: on
+#
+# Sources passed to the macro are added to the lists tracking draco sources:
+# cmake-format: off
+# - When TEST is specified sources are added to $draco_test_sources.
+# - Otherwise sources are added to $draco_sources.
+# cmake-format: on
+#
+# Targets passed to this macro are added to the lists tracking draco targets:
+# cmake-format: off
+# - Targets are always added to $draco_targets.
+# - When the TEST flag is specified, targets are added to
+# $draco_test_targets.
+# - When TEST is not specified:
+# - Libraries of type SHARED are added to $draco_dylib_targets.
+# - Libraries of type OBJECT are added to $draco_objlib_targets.
+# - Libraries of type STATIC are added to $draco_lib_targets.
+# cmake-format: on
+macro(draco_add_library)
+ unset(lib_TEST)
+ unset(lib_NAME)
+ unset(lib_OUTPUT_NAME)
+ unset(lib_TYPE)
+ unset(lib_SOURCES)
+ unset(lib_DEFINES)
+ unset(lib_INCLUDES)
+ unset(lib_COMPILE_FLAGS)
+ unset(lib_LINK_FLAGS)
+ unset(lib_OBJLIB_DEPS)
+ unset(lib_LIB_DEPS)
+ unset(lib_PUBLIC_INCLUDES)
+ unset(lib_TARGET_PROPERTIES)
+ set(optional_args TEST)
+ set(single_value_args NAME OUTPUT_NAME TYPE)
+ set(multi_value_args SOURCES DEFINES INCLUDES COMPILE_FLAGS LINK_FLAGS
+ OBJLIB_DEPS LIB_DEPS PUBLIC_INCLUDES TARGET_PROPERTIES)
+
+ cmake_parse_arguments(lib "${optional_args}" "${single_value_args}"
+ "${multi_value_args}" ${ARGN})
+
+ if(DRACO_VERBOSE GREATER 1)
+ message("--------- draco_add_library ---------\n"
+ "lib_TEST=${lib_TEST}\n"
+ "lib_NAME=${lib_NAME}\n"
+ "lib_OUTPUT_NAME=${lib_OUTPUT_NAME}\n"
+ "lib_TYPE=${lib_TYPE}\n"
+ "lib_SOURCES=${lib_SOURCES}\n"
+ "lib_DEFINES=${lib_DEFINES}\n"
+ "lib_INCLUDES=${lib_INCLUDES}\n"
+ "lib_COMPILE_FLAGS=${lib_COMPILE_FLAGS}\n"
+ "lib_LINK_FLAGS=${lib_LINK_FLAGS}\n"
+ "lib_OBJLIB_DEPS=${lib_OBJLIB_DEPS}\n"
+ "lib_LIB_DEPS=${lib_LIB_DEPS}\n"
+ "lib_PUBLIC_INCLUDES=${lib_PUBLIC_INCLUDES}\n"
+ "---------------------------------------\n")
+ endif()
+
+ if(NOT (lib_NAME AND lib_TYPE))
+ message(FATAL_ERROR "draco_add_library: NAME and TYPE required.")
+ endif()
+
+ list(APPEND draco_targets ${lib_NAME})
+ if(lib_TEST)
+ list(APPEND draco_test_targets ${lib_NAME})
+ list(APPEND draco_test_sources ${lib_SOURCES})
+ else()
+ list(APPEND draco_sources ${lib_SOURCES})
+ if(lib_TYPE STREQUAL MODULE)
+ list(APPEND draco_module_targets ${lib_NAME})
+ elseif(lib_TYPE STREQUAL OBJECT)
+ list(APPEND draco_objlib_targets ${lib_NAME})
+ elseif(lib_TYPE STREQUAL SHARED)
+ list(APPEND draco_dylib_targets ${lib_NAME})
+ elseif(lib_TYPE STREQUAL STATIC)
+ list(APPEND draco_lib_targets ${lib_NAME})
+ else()
+ message(WARNING "draco_add_library: Unhandled type: ${lib_TYPE}")
+ endif()
+ endif()
+
+ add_library(${lib_NAME} ${lib_TYPE} ${lib_SOURCES})
+ if(lib_SOURCES)
+ draco_process_intrinsics_sources(TARGET ${lib_NAME} SOURCES ${lib_SOURCES})
+ endif()
+
+ if(lib_OUTPUT_NAME)
+ if(NOT (BUILD_SHARED_LIBS AND MSVC))
+ set_target_properties(${lib_NAME}
+ PROPERTIES OUTPUT_NAME ${lib_OUTPUT_NAME})
+ endif()
+ endif()
+
+ if(lib_DEFINES)
+ target_compile_definitions(${lib_NAME} PRIVATE ${lib_DEFINES})
+ endif()
+
+ if(lib_INCLUDES)
+ target_include_directories(${lib_NAME} PRIVATE ${lib_INCLUDES})
+ endif()
+
+ if(lib_PUBLIC_INCLUDES)
+ target_include_directories(${lib_NAME} PUBLIC ${lib_PUBLIC_INCLUDES})
+ endif()
+
+ if(lib_COMPILE_FLAGS OR DRACO_CXX_FLAGS)
+ target_compile_options(${lib_NAME}
+ PRIVATE ${lib_COMPILE_FLAGS} ${DRACO_CXX_FLAGS})
+ endif()
+
+ if(lib_LINK_FLAGS)
+ set_target_properties(${lib_NAME} PROPERTIES LINK_FLAGS ${lib_LINK_FLAGS})
+ endif()
+
+ if(lib_OBJLIB_DEPS)
+ foreach(objlib_dep ${lib_OBJLIB_DEPS})
+ target_sources(${lib_NAME} PRIVATE $<TARGET_OBJECTS:${objlib_dep}>)
+ endforeach()
+ endif()
+
+ if(lib_LIB_DEPS)
+ if(lib_TYPE STREQUAL STATIC)
+ set(link_type PUBLIC)
+ else()
+ set(link_type PRIVATE)
+ if(lib_TYPE STREQUAL SHARED AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+ # The draco shared object uses the static draco as input to turn it into
+ # a shared object. Include everything from the static library in the
+ # shared object.
+ if(APPLE)
+ list(INSERT lib_LIB_DEPS 0 -Wl,-force_load)
+ else()
+ list(INSERT lib_LIB_DEPS 0 -Wl,--whole-archive)
+ list(APPEND lib_LIB_DEPS -Wl,--no-whole-archive)
+ endif()
+ endif()
+ endif()
+ target_link_libraries(${lib_NAME} ${link_type} ${lib_LIB_DEPS})
+ endif()
+
+ if(NOT MSVC AND lib_NAME MATCHES "^lib")
+ # Non-MSVC generators prepend lib to static lib target file names. Libdraco
+ # already includes lib in its name. Avoid naming output files liblib*.
+ set_target_properties(${lib_NAME} PROPERTIES PREFIX "")
+ endif()
+
+ # VERSION and SOVERSION as necessary
+ if(NOT lib_TYPE STREQUAL STATIC AND NOT lib_TYPE STREQUAL MODULE)
+ set_target_properties(${lib_NAME} PROPERTIES VERSION ${DRACO_VERSION})
+ if(NOT MSVC)
+ set_target_properties(${lib_NAME} PROPERTIES SOVERSION ${DRACO_SOVERSION})
+ endif()
+ endif()
+
+ if(BUILD_SHARED_LIBS AND (MSVC OR WIN32))
+ if(lib_TYPE STREQUAL SHARED)
+ target_compile_definitions(${lib_NAME} PRIVATE "DRACO_BUILDING_DLL=1")
+ else()
+ target_compile_definitions(${lib_NAME} PRIVATE "DRACO_BUILDING_DLL=0")
+ endif()
+ endif()
+
+ # Determine if $lib_NAME is a header only target.
+ unset(sources_list)
+ if(lib_SOURCES)
+ set(sources_list ${lib_SOURCES})
+ list(FILTER sources_list INCLUDE REGEX cc$)
+ endif()
+
+ if(NOT sources_list)
+ if(NOT XCODE)
+ # This is a header only target. Tell CMake the link language.
+ set_target_properties(${lib_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+ else()
+ # The Xcode generator ignores LINKER_LANGUAGE. Add a dummy cc file.
+ draco_create_dummy_source_file(TARGET ${lib_NAME} BASENAME ${lib_NAME})
+ endif()
+ endif()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_test_config.h.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_test_config.h.cmake
new file mode 100644
index 0000000..77a5741
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/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/src/mesh/assimp-master/contrib/draco/cmake/draco_tests.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_tests.cmake
new file mode 100644
index 0000000..a6dfc5b
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_tests.cmake
@@ -0,0 +1,133 @@
+if(DRACO_CMAKE_DRACO_TESTS_CMAKE)
+ return()
+endif()
+set(DRACO_CMAKE_DRACO_TESTS_CMAKE 1)
+
+# The factory tests are in a separate target to avoid breaking tests that rely
+# on file I/O via the factories. The fake reader and writer implementations
+# interfere with normal file I/O function.
+set(draco_factory_test_sources
+ "${draco_src_root}/io/file_reader_factory_test.cc"
+ "${draco_src_root}/io/file_writer_factory_test.cc")
+
+list(
+ APPEND
+ draco_test_sources
+ "${draco_src_root}/animation/keyframe_animation_encoding_test.cc"
+ "${draco_src_root}/animation/keyframe_animation_test.cc"
+ "${draco_src_root}/attributes/point_attribute_test.cc"
+ "${draco_src_root}/compression/attributes/point_d_vector_test.cc"
+ "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc"
+ "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc"
+ "${draco_src_root}/compression/attributes/sequential_integer_attribute_encoding_test.cc"
+ "${draco_src_root}/compression/bit_coders/rans_coding_test.cc"
+ "${draco_src_root}/compression/decode_test.cc"
+ "${draco_src_root}/compression/encode_test.cc"
+ "${draco_src_root}/compression/entropy/shannon_entropy_test.cc"
+ "${draco_src_root}/compression/entropy/symbol_coding_test.cc"
+ "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoding_test.cc"
+ "${draco_src_root}/compression/mesh/mesh_encoder_test.cc"
+ "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc"
+ "${draco_src_root}/compression/point_cloud/point_cloud_sequential_encoding_test.cc"
+ "${draco_src_root}/core/buffer_bit_coding_test.cc"
+ "${draco_src_root}/core/draco_test_base.h"
+ "${draco_src_root}/core/draco_test_utils.cc"
+ "${draco_src_root}/core/draco_test_utils.h"
+ "${draco_src_root}/core/math_utils_test.cc"
+ "${draco_src_root}/core/quantization_utils_test.cc"
+ "${draco_src_root}/core/status_test.cc"
+ "${draco_src_root}/core/vector_d_test.cc"
+ "${draco_src_root}/io/file_reader_test_common.h"
+ "${draco_src_root}/io/file_utils_test.cc"
+ "${draco_src_root}/io/stdio_file_reader_test.cc"
+ "${draco_src_root}/io/stdio_file_writer_test.cc"
+ "${draco_src_root}/io/obj_decoder_test.cc"
+ "${draco_src_root}/io/obj_encoder_test.cc"
+ "${draco_src_root}/io/ply_decoder_test.cc"
+ "${draco_src_root}/io/ply_reader_test.cc"
+ "${draco_src_root}/io/point_cloud_io_test.cc"
+ "${draco_src_root}/mesh/mesh_are_equivalent_test.cc"
+ "${draco_src_root}/mesh/mesh_cleanup_test.cc"
+ "${draco_src_root}/mesh/triangle_soup_mesh_builder_test.cc"
+ "${draco_src_root}/metadata/metadata_encoder_test.cc"
+ "${draco_src_root}/metadata/metadata_test.cc"
+ "${draco_src_root}/point_cloud/point_cloud_builder_test.cc"
+ "${draco_src_root}/point_cloud/point_cloud_test.cc")
+
+list(APPEND draco_gtest_all
+ "${draco_root}/../googletest/googletest/src/gtest-all.cc")
+list(APPEND draco_gtest_main
+ "${draco_root}/../googletest/googletest/src/gtest_main.cc")
+
+macro(draco_setup_test_targets)
+ if(DRACO_TESTS)
+ if(NOT (EXISTS ${draco_gtest_all} AND EXISTS ${draco_gtest_main}))
+ message(FATAL "googletest must be a sibling directory of ${draco_root}.")
+ endif()
+
+ list(APPEND draco_test_defines GTEST_HAS_PTHREAD=0)
+
+ draco_add_library(TEST
+ NAME
+ draco_gtest
+ TYPE
+ STATIC
+ SOURCES
+ ${draco_gtest_all}
+ DEFINES
+ ${draco_defines}
+ ${draco_test_defines}
+ INCLUDES
+ ${draco_test_include_paths})
+
+ draco_add_library(TEST
+ NAME
+ draco_gtest_main
+ TYPE
+ STATIC
+ SOURCES
+ ${draco_gtest_main}
+ DEFINES
+ ${draco_defines}
+ ${draco_test_defines}
+ INCLUDES
+ ${draco_test_include_paths})
+
+ set(DRACO_TEST_DATA_DIR "${draco_root}/testdata")
+ set(DRACO_TEST_TEMP_DIR "${draco_build}/draco_test_temp")
+ file(MAKE_DIRECTORY "${DRACO_TEST_TEMP_DIR}")
+
+ # Sets DRACO_TEST_DATA_DIR and DRACO_TEST_TEMP_DIR.
+ configure_file("${draco_root}/cmake/draco_test_config.h.cmake"
+ "${draco_build}/testing/draco_test_config.h")
+
+ # Create the test targets.
+ draco_add_executable(NAME
+ draco_tests
+ SOURCES
+ ${draco_test_sources}
+ DEFINES
+ ${draco_defines}
+ ${draco_test_defines}
+ INCLUDES
+ ${draco_test_include_paths}
+ LIB_DEPS
+ draco_static
+ draco_gtest
+ draco_gtest_main)
+
+ draco_add_executable(NAME
+ draco_factory_tests
+ SOURCES
+ ${draco_factory_test_sources}
+ DEFINES
+ ${draco_defines}
+ ${draco_test_defines}
+ INCLUDES
+ ${draco_test_include_paths}
+ LIB_DEPS
+ draco_static
+ draco_gtest
+ draco_gtest_main)
+ endif()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/draco_variables.cmake b/src/mesh/assimp-master/contrib/draco/cmake/draco_variables.cmake
new file mode 100644
index 0000000..8dbc77a
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/draco_variables.cmake
@@ -0,0 +1,64 @@
+if(DRACO_CMAKE_DRACO_VARIABLES_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_DRACO_VARIABLES_CMAKE_
+set(DRACO_CMAKE_DRACO_VARIABLES_CMAKE_ 1)
+
+# Halts generation when $variable_name does not refer to a directory that
+# exists.
+macro(draco_variable_must_be_directory variable_name)
+ if("${variable_name}" STREQUAL "")
+ message(
+ FATAL_ERROR
+ "Empty variable_name passed to draco_variable_must_be_directory.")
+ endif()
+
+ if("${${variable_name}}" STREQUAL "")
+ message(
+ FATAL_ERROR
+ "Empty variable ${variable_name} is required to build draco.")
+ endif()
+
+ if(NOT IS_DIRECTORY "${${variable_name}}")
+ message(
+ FATAL_ERROR
+ "${variable_name}, which is ${${variable_name}}, does not refer to a\n"
+ "directory.")
+ endif()
+endmacro()
+
+# Adds $var_name to the tracked variables list.
+macro(draco_track_configuration_variable var_name)
+ if(DRACO_VERBOSE GREATER 2)
+ message("---- draco_track_configuration_variable ----\n"
+ "var_name=${var_name}\n"
+ "----------------------------------------------\n")
+ endif()
+
+ list(APPEND draco_configuration_variables ${var_name})
+ list(REMOVE_DUPLICATES draco_configuration_variables)
+endmacro()
+
+# Logs current C++ and executable linker flags via the CMake message command.
+macro(draco_dump_cmake_flag_variables)
+ unset(flag_variables)
+ list(APPEND flag_variables "CMAKE_CXX_FLAGS_INIT" "CMAKE_CXX_FLAGS"
+ "CMAKE_EXE_LINKER_FLAGS_INIT" "CMAKE_EXE_LINKER_FLAGS")
+ if(CMAKE_BUILD_TYPE)
+ list(APPEND flag_variables "CMAKE_BUILD_TYPE"
+ "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}_INIT"
+ "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}"
+ "CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE}_INIT"
+ "CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE}")
+ endif()
+ foreach(flag_variable ${flag_variables})
+ message("${flag_variable}:${${flag_variable}}")
+ endforeach()
+endmacro()
+
+# Dumps the variables tracked in $draco_configuration_variables via the CMake
+# message command.
+macro(draco_dump_tracked_configuration_variables)
+ foreach(config_variable ${draco_configuration_variables})
+ message("${config_variable}:${${config_variable}}")
+ endforeach()
+endmacro()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/sanitizers.cmake b/src/mesh/assimp-master/contrib/draco/cmake/sanitizers.cmake
new file mode 100644
index 0000000..e720bc0
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/sanitizers.cmake
@@ -0,0 +1,19 @@
+if(DRACO_CMAKE_SANITIZERS_CMAKE_)
+ return()
+endif()
+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)
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
new file mode 100644
index 0000000..87e0b4a
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_
+set(DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+ set(CROSS aarch64-linux-gnu-)
+endif()
+
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(CMAKE_CXX_FLAGS_INIT "-march=armv8-a")
+set(CMAKE_SYSTEM_PROCESSOR "aarch64")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/android-ndk-common.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/android-ndk-common.cmake
new file mode 100644
index 0000000..5126d6e
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/android-ndk-common.cmake
@@ -0,0 +1,23 @@
+if(DRACO_CMAKE_TOOLCHAINS_ANDROID_NDK_COMMON_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ANDROID_NDK_COMMON_CMAKE_ 1)
+
+# Toolchain files do not have access to cached variables:
+# https://gitlab.kitware.com/cmake/cmake/issues/16170. Set an intermediate
+# environment variable when loaded the first time.
+if(DRACO_ANDROID_NDK_PATH)
+ set(ENV{DRACO_ANDROID_NDK_PATH} "${DRACO_ANDROID_NDK_PATH}")
+else()
+ set(DRACO_ANDROID_NDK_PATH "$ENV{DRACO_ANDROID_NDK_PATH}")
+endif()
+
+set(CMAKE_SYSTEM_NAME Android)
+
+if(NOT CMAKE_ANDROID_STL_TYPE)
+ set(CMAKE_ANDROID_STL_TYPE c++_static)
+endif()
+
+if(NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
+ set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION clang)
+endif()
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/android.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/android.cmake
new file mode 100644
index 0000000..b8f576d
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/android.cmake
@@ -0,0 +1,39 @@
+if(DRACO_CMAKE_TOOLCHAINS_ANDROID_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_TOOLCHAINS_ANDROID_CMAKE_
+
+# Additional ANDROID_* settings are available, see:
+# https://developer.android.com/ndk/guides/cmake#variables
+
+if(NOT ANDROID_PLATFORM)
+ set(ANDROID_PLATFORM android-21)
+endif()
+
+# Choose target architecture with:
+#
+# -DANDROID_ABI={armeabi-v7a,armeabi-v7a with NEON,arm64-v8a,x86,x86_64}
+if(NOT ANDROID_ABI)
+ set(ANDROID_ABI arm64-v8a)
+endif()
+
+# Force arm mode for 32-bit targets (instead of the default thumb) to improve
+# performance.
+if(NOT ANDROID_ARM_MODE)
+ set(ANDROID_ARM_MODE arm)
+endif()
+
+# Toolchain files do not have access to cached variables:
+# https://gitlab.kitware.com/cmake/cmake/issues/16170. Set an intermediate
+# environment variable when loaded the first time.
+if(DRACO_ANDROID_NDK_PATH)
+ set(ENV{DRACO_ANDROID_NDK_PATH} "${DRACO_ANDROID_NDK_PATH}")
+else()
+ set(DRACO_ANDROID_NDK_PATH "$ENV{DRACO_ANDROID_NDK_PATH}")
+endif()
+
+if(NOT DRACO_ANDROID_NDK_PATH)
+ message(FATAL_ERROR "DRACO_ANDROID_NDK_PATH not set.")
+ return()
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-ios-common.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-ios-common.cmake
new file mode 100644
index 0000000..65326d1
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-ios-common.cmake
@@ -0,0 +1,17 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM_IOS_COMMON_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_ARM_IOS_COMMON_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Darwin")
+if(CMAKE_OSX_SDK)
+ set(CMAKE_OSX_SYSROOT ${CMAKE_OSX_SDK})
+else()
+ set(CMAKE_OSX_SYSROOT iphoneos)
+endif()
+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.
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
new file mode 100644
index 0000000..6e45969
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_)
+ return()
+endif() # DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_
+set(DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+ set(CROSS arm-linux-gnueabihf-)
+endif()
+
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(CMAKE_CXX_FLAGS_INIT "-march=armv7-a -marm")
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
+set(DRACO_NEON_INTRINSICS_FLAG "-mfpu=neon")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
new file mode 100644
index 0000000..4b6d366
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+ set(ANROID_PLATFORM android-21)
+endif()
+
+if(NOT ANDROID_ABI)
+ set(ANDROID_ABI arm64-v8a)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-ios.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-ios.cmake
new file mode 100644
index 0000000..c4ec7e3
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_)
+ return()
+endif()
+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")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
new file mode 100644
index 0000000..046ff01
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
@@ -0,0 +1,18 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_)
+ return()
+endif()
+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")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
new file mode 100644
index 0000000..80ee98b
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+ set(ANDROID_PLATFORM android-18)
+endif()
+
+if(NOT ANDROID_ABI)
+ set(ANDROID_ABI armeabi-v7a)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-ios.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-ios.cmake
new file mode 100644
index 0000000..8ddd699
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_)
+ return()
+endif()
+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")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
new file mode 100644
index 0000000..9c94723
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
@@ -0,0 +1,24 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_)
+ return()
+endif()
+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")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7s-ios.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7s-ios.cmake
new file mode 100644
index 0000000..b433025
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/armv7s-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_)
+ return()
+endif()
+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")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/i386-ios.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/i386-ios.cmake
new file mode 100644
index 0000000..e9a1055
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/i386-ios.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_i386_IOS_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_i386_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 "i386")
+set(CMAKE_OSX_ARCHITECTURES "i386")
+set(CMAKE_OSX_SDK "iphonesimulator")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
new file mode 100644
index 0000000..d433836
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+ set(ANDROID_PLATFORM android-18)
+endif()
+
+if(NOT ANDROID_ABI)
+ set(ANDROID_ABI x86)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
new file mode 100644
index 0000000..d6fabea
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+ set(ANDROID_PLATFORM android-21)
+endif()
+
+if(NOT ANDROID_ABI)
+ set(ANDROID_ABI x86_64)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-ios.cmake b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-ios.cmake
new file mode 100644
index 0000000..4c50a72
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/toolchains/x86_64-ios.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_64_IOS_CMAKE_)
+ return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_64_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 "x86_64")
+set(CMAKE_OSX_ARCHITECTURES "x86_64")
+set(CMAKE_OSX_SDK "iphonesimulator")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/src/mesh/assimp-master/contrib/draco/cmake/util.cmake b/src/mesh/assimp-master/contrib/draco/cmake/util.cmake
new file mode 100644
index 0000000..813146a
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/draco/cmake/util.cmake
@@ -0,0 +1,79 @@
+if(DRACO_CMAKE_UTIL_CMAKE_)
+ return()
+endif()
+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}.new"
+ "// 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")
+
+ # Will replace ${dummy_source_file} only if the file content has changed.
+ # This prevents forced Draco rebuilds after CMake runs.
+ configure_file("${dummy_source_file}.new" "${dummy_source_file}")
+ file(REMOVE "${dummy_source_file}.new")
+
+ 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.
+macro(set_variable_if_unset var_name default_value)
+ if(NOT "$ENV{${var_name}}" STREQUAL "")
+ set(${var_name} $ENV{${var_name}})
+ elseif(NOT ${var_name})
+ set(${var_name} ${default_value})
+ endif()
+endmacro()