Merge pull request #192 from rpavlik/buildsys

Portability and Build System Cleanup

Author: rpavlik

.gitignore

@@ -28,6 +28,8 @@ out/build/
 # VS misc
 *.sln
 *.pyproj
+CMakeSettings.json
+CppProperties.json
 
 # Don't ignore pipeline stuff
 !.azure-pipelines/

changes/sdk/pr.192.gh.OpenXR-SDK-Source.md

@@ -0,0 +1,4 @@
+---
+- pr.188.gh.OpenXR-SDK-Source
+---
+Allow disabling of std::filesystem usage, and detect if it's available and what its requirements are.

external/include/GL/gl_format.h

@@ -92,11 +92,13 @@ static inline void glGetFormatSize( const GLenum internalFormat, GlFormatSize *
 #include <assert.h>
 
 #if defined(_WIN32)
+#ifndef NOMINMAX
 #define NOMINMAX
-#ifndef __cplusplus
+#endif
+#if defined(_MSC_VER) && !defined(__cplusplus)
 #undef inline
 #define inline __inline
-#endif // __cplusplus
+#endif // defined(_MSC_VER) && !defined(__cplusplus)
 #endif
 
 typedef unsigned int GLenum;

external/include/utils/threading.h

@@ -535,7 +535,8 @@ typedef struct
 // Note that on Android AttachCurrentThread will reset the thread name.
 static void ksThread_SetName( const char * name )
 {
-#if defined( OS_WINDOWS )
+	(void)name;
+#if defined( OS_WINDOWS ) && !defined(__MINGW32__)
 	static const unsigned int MS_VC_EXCEPTION = 0x406D1388;
 
 #pragma pack( push, 8 )

src/CMakeLists.txt

@@ -17,27 +17,30 @@
 # Author:
 #
 
+if(POLICY CMP0075)
+    cmake_policy(SET CMP0075 NEW)
+endif()
+
 # Entire project uses C++14
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 include(GNUInstallDirs)
+include(StdFilesystemFlags)
 
 ### Dependencies
 set(OpenGL_GL_PREFERENCE GLVND)
-if (NOT CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+if(NOT CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
     # OpenGL package will be found for UWP apps but gl.h excludes UWP apps so it isn't actually usable.
-find_package(OpenGL)
+    find_package(OpenGL)
 endif()
 
 if(OPENGL_FOUND)
     add_definitions(-DXR_USE_GRAPHICS_API_OPENGL)
     message(STATUS "Enabling OpenGL support")
-elseif(BUILD_ALL_EXTENSIONS)
-    if (NOT CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
-        message(FATAL_ERROR "OpenGL not found")
-    endif()
+elseif(BUILD_ALL_EXTENSIONS AND NOT CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+    message(FATAL_ERROR "OpenGL not found")
 endif()
 
 if(NOT CMAKE_VERSION VERSION_LESS 3.7.0)
@@ -63,6 +66,7 @@ option(
     "Enable exception handling in the loader. Leave this on unless your standard library is built to not throw."
     ON
 )
+
 if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     option(DYNAMIC_LOADER "Build the loader as a .dll library" OFF)
 else()
@@ -82,6 +86,8 @@ include(CMakeDependentOption)
 cmake_dependent_option(
     BUILD_WITH_SYSTEM_JSONCPP "Use system jsoncpp instead of vendored source" ON "JSONCPP_FOUND" OFF
 )
+cmake_dependent_option(BUILD_WITH_STD_FILESYSTEM "Use std::[experimental::]filesystem." ON
+       "HAVE_FILESYSTEM_WITHOUT_LIB OR HAVE_FILESYSTEM_NEEDING_LIB" OFF)
 
 # Several files use these compile-time OS switches
 if(WIN32)
@@ -91,9 +97,9 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 endif()
 
 # /EHsc (support for C++ exceptions) is default in most configurations but seems missing when building arm/arm64.
-IF(MSVC)
-    SET(CMAKE_CXX_FLAGS "/EHsc")
-ENDIF(MSVC)
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
+endif()
 
 # This is a little helper library for setting up OpenGL
 if(OPENGL_FOUND AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/common/gfxwrapper_opengl.c")
@@ -195,8 +201,26 @@ function(compile_glsl run_target_name)
 endfunction()
 
 if(WIN32)
-    add_definitions(-DXR_USE_GRAPHICS_API_D3D11)
-    add_definitions(-DXR_USE_GRAPHICS_API_D3D12)
+    # This is too simple of detection to be worth separating into a find module
+    find_library(D3D_DXGI_LIBRARY dxgi)
+    find_library(D3D_COMPILER_LIBRARY d3dcompiler)
+    find_path(D3D_D3D11_INCLUDE_DIR d3d11.h)
+    find_library(D3D_D3D11_LIBRARY d3d11)
+    if(D3D_D3D11_INCLUDE_DIR AND D3D_D3D11_LIBRARY AND D3D_DXGI_LIBRARY AND D3D_COMPILER_LIBRARY)
+        set(D3D_D3D11_FOUND ON)
+        set(D3D_D3D11_LIBRARIES ${D3D_D3D11_LIBRARY} ${D3D_DXGI_LIBRARY} ${D3D_COMPILER_LIBRARY})
+        add_definitions(-DXR_USE_GRAPHICS_API_D3D11)
+    endif()
+
+    find_path(D3D_D3D12_INCLUDE_DIR d3d12.h)
+    find_library(D3D_D3D12_LIBRARY d3d12)
+    if(D3D_D3D12_INCLUDE_DIR AND D3D_D3D12_LIBRARY AND D3D_DXGI_LIBRARY)
+        set(D3D_D3D12_FOUND ON)
+        set(D3D_D3D12_LIBRARIES ${D3D_D3D12_LIBRARY} ${D3D_DXGI_LIBRARY} ${D3D_COMPILER_LIBRARY})
+        add_definitions(-DXR_USE_GRAPHICS_API_D3D12)
+    endif()
+
+    find_path(D3D_DIRECTXCOLORS_INCLUDE_DIR DirectXColors.h)
 endif()
 
 # Check for the existence of the secure_getenv or __secure_getenv commands
@@ -217,7 +241,7 @@ include(${CMAKE_CURRENT_SOURCE_DIR}/version.cmake)
 
 # Path separators ( : or ; ) are not handled well in CMake.
 # This seems like a reasonable approach.
-if(WIN32)
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
     set(CODEGEN_PYTHON_PATH
         "${PROJECT_SOURCE_DIR}/specification/scripts;${PROJECT_SOURCE_DIR}/src/scripts;$ENV{PYTHONPATH}"
     )
@@ -296,12 +320,17 @@ set_target_properties(xr_global_generated_files PROPERTIES FOLDER ${CODEGEN_FOLD
 set(COMMON_GENERATED_OUTPUT ${GENERATED_OUTPUT})
 if(NOT MSVC)
     include(CheckCXXCompilerFlag)
-    foreach(FLAG -Wall -Werror=unused-parameter -Werror=unused-argument)
+    include(CheckCCompilerFlag)
+    foreach(FLAG -Wall -Werror=unused-parameter -Werror=unused-argument -Wpointer-arith)
         string(REGEX REPLACE "[^A-Za-z0-9]" "" _flagvar "${FLAG}")
         check_cxx_compiler_flag(${FLAG} SUPPORTS_${_flagvar})
-        if(SUPPORTS_WARNING_${_flagvar})
+        if(SUPPORTS_${_flagvar})
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}")
         endif()
+        check_c_compiler_flag(${FLAG} SUPPORTS_C_${_flagvar})
+        if(SUPPORTS_C_${_flagvar})
+            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAG}")
+        endif()
     endforeach()
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
 endif()

src/api_layers/CMakeLists.txt

@@ -67,7 +67,7 @@ add_library(XrApiLayer_api_dump SHARED
 )
 set_target_properties(XrApiLayer_api_dump PROPERTIES FOLDER ${API_LAYERS_FOLDER})
 
-target_link_libraries(XrApiLayer_api_dump PRIVATE openxr-all-supported)
+target_link_libraries(XrApiLayer_api_dump PRIVATE openxr-all-supported ${CMAKE_THREAD_LIBS_INIT})
 add_dependencies(XrApiLayer_api_dump
     generate_openxr_header
     xr_global_generated_files
@@ -129,7 +129,7 @@ add_library(XrApiLayer_core_validation SHARED
 )
 set_target_properties(XrApiLayer_core_validation PROPERTIES FOLDER ${API_LAYERS_FOLDER})
 
-target_link_libraries(XrApiLayer_core_validation PRIVATE openxr-all-supported)
+target_link_libraries(XrApiLayer_core_validation PRIVATE openxr-all-supported ${CMAKE_THREAD_LIBS_INIT})
 add_dependencies(XrApiLayer_core_validation
     generate_openxr_header
     xr_global_generated_files
@@ -186,20 +186,16 @@ if(WIN32)
 	set_target_properties(copy-core_validation-def-file PROPERTIES FOLDER ${HELPER_FOLDER})
 elseif(APPLE)
     # Apple api_dump-specific information
-    target_compile_options(XrApiLayer_api_dump PRIVATE -Wpointer-arith -Wno-unused-function -Wno-sign-compare)
     set_target_properties(XrApiLayer_api_dump PROPERTIES LINK_FLAGS "-Wl")
 
     # Apple core_validation-specific information
-    target_compile_options(XrApiLayer_core_validation PRIVATE -Wpointer-arith -Wno-unused-function -Wno-sign-compare)
     set_target_properties(XrApiLayer_core_validation PROPERTIES LINK_FLAGS "-Wl")
 
 else()
     # Linux api_dump-specific information
-    target_compile_options(XrApiLayer_api_dump PRIVATE -Wpointer-arith -Wno-unused-function -Wno-sign-compare)
     set_target_properties(XrApiLayer_api_dump PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic,--exclude-libs,ALL")
 
     # Linux core_validation-specific information
-    target_compile_options(XrApiLayer_core_validation PRIVATE -Wpointer-arith -Wno-unused-function -Wno-sign-compare)
     set_target_properties(XrApiLayer_core_validation PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic,--exclude-libs,ALL")
 endif()
 

src/cmake/StdFilesystemFlags.cmake

@@ -0,0 +1,136 @@
+#  Copyright 2020, Collabora, Ltd.
+#
+# SPDX-License-Identifier: BSL-1.0
+
+if(MSVC AND MSVC_VERSION GREATER 1890)
+    set(HAVE_FILESYSTEM_WITHOUT_LIB
+        ON
+        CACHE INTERNAL "" FORCE)
+    if(MSVC_VERSION GREATER 1910)
+        # Visual Studio 2017 Update 3 added new filesystem impl,
+        # which only works in C++17 mode.
+        set(HAVE_FILESYSTEM_NEEDS_17
+            ON
+            CACHE INTERNAL "" FORCE)
+    endif()
+else()
+    include(CheckCXXSourceCompiles)
+
+    # This is just dummy code that is known to not compile if std::filesystem isn't working right
+    set(_stdfs_test_source
+        "int main() {
+        (void)is_regular_file(\"/\");
+        return 0;
+    }
+    "
+    )
+    set(_stdfs_conditions
+        "// If the C++ macro is set to the version containing C++17, it must support
+        // the final C++17 package
+        #if __cplusplus >= 201703L
+        #define USE_FINAL_FS 1
+
+        #elif defined(_MSC_VER) && _MSC_VER >= 1900
+
+        #if defined(_HAS_CXX17) && _HAS_CXX17
+        // When MSC supports c++17 use <filesystem> package.
+        #define USE_FINAL_FS 1
+        #endif  // !_HAS_CXX17
+
+        // Right now, GCC still only supports the experimental filesystem items starting in GCC 6
+        #elif (__GNUC__ >= 6)
+        #define USE_EXPERIMENTAL_FS 1
+
+        // If Clang, check for feature support
+        #elif defined(__clang__) && (__cpp_lib_filesystem || __cpp_lib_experimental_filesystem)
+        #if __cpp_lib_filesystem
+        #define USE_FINAL_FS 1
+        #else
+        #define USE_EXPERIMENTAL_FS 1
+        #endif
+
+        #endif
+    ")
+    set(_stdfs_source
+        "${_stdfs_conditions}
+    #ifdef USE_FINAL_FS
+    #include <filesystem>
+    using namespace std::filesystem;
+    #endif
+    ${_stdfs_test_source}
+    "
+    )
+    set(_stdfs_experimental_source
+    "${_stdfs_conditions}
+    #ifdef USE_EXPERIMENTAL_FS
+    #include <experimental/filesystem>
+    using namespace std::experimental::filesystem;
+    #endif
+    ${_stdfs_test_source}
+    "
+    )
+    set(_stdfs_needlib_source
+        "${_stdfs_conditions}
+    #ifdef USE_FINAL_FS
+    #include <filesystem>
+    using namespace std::filesystem;
+    #endif
+    #ifdef USE_EXPERIMENTAL_FS
+    #include <experimental/filesystem>
+    using namespace std::experimental::filesystem;
+    #endif
+    ${_stdfs_test_source}
+    "
+    )
+
+    # First, just look for the include.
+    # We're checking if it compiles, not if the include exists,
+    # because the source code uses similar conditionals to decide.
+    set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+    unset(CMAKE_REQUIRED_LIBRARIES)
+    unset(CMAKE_REQUIRED_FLAGS)
+    check_cxx_source_compiles("${_stdfs_source}" HAVE_FILESYSTEM_IN_STD)
+    check_cxx_source_compiles("${_stdfs_experimental_source}" HAVE_FILESYSTEM_IN_STDEXPERIMENTAL)
+
+    set(CMAKE_REQUIRED_FLAGS "-DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=TRUE")
+    check_cxx_source_compiles("${_stdfs_source}" HAVE_FILESYSTEM_IN_STD_17)
+    unset(CMAKE_REQUIRED_FLAGS)
+
+    if(HAVE_FILESYSTEM_IN_STD_17 AND NOT HAVE_FILESYSTEM_IN_STD)
+        set(HAVE_FILESYSTEM_NEEDS_17
+            ON
+            CACHE INTERNAL ""
+        )
+        set(CMAKE_REQUIRED_FLAGS "-DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=TRUE")
+    else()
+        set(HAVE_FILESYSTEM_NEEDS_17
+            OFF
+            CACHE INTERNAL ""
+        )
+    endif()
+
+    # Now, see if we need libstdc++fs
+    set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE)
+    check_cxx_source_compiles("${_stdfs_needlib_source}" HAVE_FILESYSTEM_WITHOUT_LIB)
+    set(CMAKE_REQUIRED_LIBRARIES stdc++fs)
+    check_cxx_source_compiles("${_stdfs_needlib_source}" HAVE_FILESYSTEM_NEEDING_LIB)
+    unset(CMAKE_REQUIRED_LIBRARIES)
+    unset(CMAKE_TRY_COMPILE_TARGET_TYPE)
+
+endif()
+
+function(openxr_add_filesystem_utils TARGET_NAME)
+    target_sources(${TARGET_NAME} PRIVATE ${PROJECT_SOURCE_DIR}/src/common/filesystem_utils.cpp)
+    target_include_directories(${TARGET_NAME} PRIVATE ${PROJECT_SOURCE_DIR}/src/common)
+    if(NOT BUILD_WITH_STD_FILESYSTEM)
+        target_compile_definitions(${TARGET_NAME} PRIVATE DISABLE_STD_FILESYSTEM)
+    else()
+        if(HAVE_FILESYSTEM_NEEDS_17)
+            set_property(TARGET ${TARGET_NAME} PROPERTY CXX_STANDARD 17)
+            set_property(TARGET ${TARGET_NAME} PROPERTY CXX_STANDARD_REQUIRED TRUE)
+        endif()
+        if(HAVE_FILESYSTEM_NEEDING_LIB AND NOT HAVE_FILESYSTEM_WITHOUT_LIB)
+            target_link_libraries(${TARGET_NAME} PRIVATE stdc++fs)
+        endif()
+    endif()
+endfunction()

src/common/filesystem_utils.cpp

@@ -25,6 +25,7 @@
 #include "platform_utils.hpp"
 
 #include <cstring>
+#include <string>
 
 #if defined DISABLE_STD_FILESYSTEM
 #define USE_EXPERIMENTAL_FS 0

src/common/gfxwrapper_opengl.c

@@ -3190,6 +3190,10 @@ ksGpuWindowEvent ksGpuWindow_ProcessEvents(ksGpuWindow *window) {
 
 #elif defined(OS_LINUX_WAYLAND)
 
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
 static void _keyboard_keymap_cb(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) { close(fd); }
 static void _keyboard_modifiers_cb(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed,
                                    uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {}
@@ -3337,11 +3341,16 @@ static void _registry_cb(void *data, struct wl_registry *registry, uint32_t id,
 
 static void _registry_remove_cb(void *data, struct wl_registry *registry, uint32_t id) {}
 
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
 const struct wl_registry_listener registry_listener = {_registry_cb, _registry_remove_cb};
 
 bool ksGpuWindow_Create(ksGpuWindow *window, ksDriverInstance *instance, const ksGpuQueueInfo *queueInfo, const int queueIndex,
                         const ksGpuSurfaceColorFormat colorFormat, const ksGpuSurfaceDepthFormat depthFormat,
                         const ksGpuSampleCount sampleCount, const int width, const int height, const bool fullscreen) {
+    (void)queueIndex;
     memset(window, 0, sizeof(ksGpuWindow));
 
     window->display = NULL;