build: Add an internal-use static library for gfxwrapper.

rpavlik · rpavlik · commit 93e952bcc259 · 2019-12-13T12:30:16.000-06:00
Helping to untangle the deps

Signed-off-by: Ryan Pavlik &lt;ryan.pavlik@collabora.com&gt;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -21,6 +21,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 ### Dependencies
+set(OpenGL_GL_PREFERENCE GLVND)
 find_package(OpenGL)
 if(OPENGL_FOUND)
     add_definitions(-DXR_USE_GRAPHICS_API_OPENGL)
@@ -72,6 +73,19 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     add_definitions(-DXR_OS_LINUX)
 endif()
 
+# This is a little helper library for setting up OpenGL
+if(OPENGL_FOUND AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/common/gfxwrapper_opengl.c")
+    add_library(openxr-gfxwrapper STATIC common/gfxwrapper_opengl.c common/gfxwrapper_opengl.h)
+    target_include_directories(openxr-gfxwrapper PUBLIC ${PROJECT_SOURCE_DIR}/external/include)
+    if(TARGET OpenGL::OpenGL)
+        target_link_libraries(openxr-gfxwrapper PUBLIC OpenGL::OpenGL)
+    elseif(TARGET OpenGL::GL)
+        target_link_libraries(openxr-gfxwrapper PUBLIC OpenGL::GL)
+    else()
+        target_link_libraries(openxr-gfxwrapper PUBLIC ${OPENGL_LIBRARIES})
+    endif()
+endif()
+
 # Determine the presentation backend for Linux systems.
 # Use an include because the code is pretty big.
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
diff --git a/src/cmake/presentation.cmake b/src/cmake/presentation.cmake
@@ -1,101 +1,105 @@
 set(PRESENTATION_BACKENDS xlib xcb wayland)
-set(PRESENTATION_BACKEND xlib CACHE STRING
-    "Presentation backend chosen at configure time")
-set_property(CACHE PRESENTATION_BACKEND PROPERTY STRINGS
-                ${PRESENTATION_BACKENDS})
+set(PRESENTATION_BACKEND
+    xlib
+    CACHE STRING "Presentation backend chosen at configure time"
+)
+set_property(CACHE PRESENTATION_BACKEND PROPERTY STRINGS ${PRESENTATION_BACKENDS})
 
 list(FIND PRESENTATION_BACKENDS ${PRESENTATION_BACKEND} index)
 if(index EQUAL -1)
-    message(FATAL_ERROR "Presentation backend must be one of
-            ${PRESENTATION_BACKENDS}")
+    message(FATAL_ERROR "Presentation backend must be one of ${PRESENTATION_BACKENDS}")
 endif()
 
 message(STATUS "Using presentation backend: ${PRESENTATION_BACKEND}")
 
+find_package(X11)
 
-if( PRESENTATION_BACKEND MATCHES "xlib" )
-    find_package(X11 REQUIRED)
-    if (BUILD_TESTS AND ((NOT X11_Xxf86vm_LIB) OR (NOT X11_Xrandr_LIB)))
+find_package(PkgConfig)
+
+if(PKG_CONFIG_FOUND)
+    pkg_search_module(XCB xcb)
+
+    pkg_search_module(WAYLAND_CLIENT wayland-client)
+endif()
+
+
+if(PRESENTATION_BACKEND MATCHES "xlib")
+    if(BUILD_TESTS AND (NOT X11_Xxf86vm_LIB OR NOT X11_Xrandr_LIB))
         message(FATAL_ERROR "OpenXR tests using xlib backend requires Xxf86vm and Xrandr")
     endif()
 
-    add_definitions( -DSUPPORT_X )
-    add_definitions( -DOS_LINUX_XLIB )
-    set( XLIB_LIBRARIES
-            ${X11_LIBRARIES}
-            ${X11_Xxf86vm_LIB}
-            ${X11_Xrandr_LIB} )
-
-elseif( PRESENTATION_BACKEND MATCHES "xcb" )
-    find_package(PkgConfig REQUIRED)
-    # XCB + XCB GLX is limited to OpenGL 2.1
-    # add_definitions( -DOS_LINUX_XCB )
-    # XCB + Xlib GLX 1.3
-    add_definitions( -DOS_LINUX_XCB_GLX )
-
-    pkg_search_module(X11 REQUIRED x11)
-    pkg_search_module(XCB REQUIRED xcb)
+    if(TARGET openxr-gfxwrapper)
+        target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_XLIB)
+        target_link_libraries(openxr-gfxwrapper PRIVATE ${X11_X11_LIB} ${X11_Xxf86vm_LIB} ${X11_Xrandr_LIB})
+
+        if(TARGET OpenGL::OpenGL)
+            target_link_libraries(openxr-gfxwrapper PUBLIC OpenGL::OpenGL)
+        elseif(TARGET OpenGL::GLX)
+            target_link_libraries(openxr-gfxwrapper PUBLIC OpenGL::GLX)
+        else()
+            target_link_libraries(openxr-gfxwrapper PUBLIC ${OPENGL_LIBRARIES} ${OPENGL_glx_LIBRARY})
+        endif()
+    endif()
+elseif(PRESENTATION_BACKEND MATCHES "xcb")
     pkg_search_module(XCB_RANDR REQUIRED xcb-randr)
     pkg_search_module(XCB_KEYSYMS REQUIRED xcb-keysyms)
     pkg_search_module(XCB_GLX REQUIRED xcb-glx)
     pkg_search_module(XCB_DRI2 REQUIRED xcb-dri2)
     pkg_search_module(XCB_ICCCM REQUIRED xcb-icccm)
 
-    set( XCB_LIBRARIES
-            ${XCB_LIBRARIES}
-            ${XCB_KEYSYMS_LIBRARIES}
-            ${XCB_RANDR_LIBRARIES}
-            ${XCB_GLX_LIBRARIES}
-            ${XCB_DRI2_LIBRARIES}
-            ${X11_LIBRARIES} )
-
-elseif( PRESENTATION_BACKEND MATCHES "wayland" )
-    find_package(PkgConfig REQUIRED)
-    pkg_search_module(WAYLAND_CLIENT REQUIRED wayland-client)
+    if(TARGET openxr-gfxwrapper)
+        # XCB + XCB GLX is limited to OpenGL 2.1
+        # target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_XCB )
+        # XCB + Xlib GLX 1.3
+        target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_XCB_GLX)
+
+        target_link_libraries(openxr-gfxwrapper PRIVATE ${X11_X11_LIB} ${XCB_KEYSYMS_LIBRARIES} ${XCB_RANDR_LIBRARIES})
+    endif()
+elseif(PRESENTATION_BACKEND MATCHES "wayland")
+
     pkg_search_module(WAYLAND_EGL REQUIRED wayland-egl)
     pkg_search_module(WAYLAND_SCANNER REQUIRED wayland-scanner)
     pkg_search_module(WAYLAND_PROTOCOLS REQUIRED wayland-protocols>=1.7)
     pkg_search_module(EGL REQUIRED egl)
 
-    add_definitions( -DOS_LINUX_WAYLAND )
-    set( WAYLAND_LIBRARIES
-            ${EGL_LIBRARIES}
-            ${WAYLAND_CLIENT_LIBRARIES}
-            ${WAYLAND_EGL_LIBRARIES} )
-
-    # generate wayland protocols
-    set(WAYLAND_PROTOCOLS_DIR ${PROJECT_SOURCE_DIR}/wayland-protocols/)
-    file(MAKE_DIRECTORY ${WAYLAND_PROTOCOLS_DIR})
-
-    pkg_get_variable(WAYLAND_PROTOCOLS_DATADIR wayland-protocols pkgdatadir)
-    pkg_get_variable(WAYLAND_SCANNER wayland-scanner wayland_scanner)
-
-    set(PROTOCOL xdg-shell-unstable-v6)
-    set(PROTOCOL_XML
-        ${WAYLAND_PROTOCOLS_DATADIR}/unstable/xdg-shell/${PROTOCOL}.xml)
-
-    if( EXISTS ${PROTOCOL_XML} )
-        execute_process(COMMAND
-                        ${WAYLAND_SCANNER}
-                        code
-                        ${PROTOCOL_XML}
-                        ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c)
-        execute_process(COMMAND
-                        ${WAYLAND_SCANNER}
-                        client-header
-                        ${PROTOCOL_XML}
-                        ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h)
-
-        set( WAYLAND_PROTOCOL_SRC
-                ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c
-                ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h )
-
-        include_directories(${WAYLAND_PROTOCOLS_DIR})
-    else()
-        message(FATAL_ERROR
-                "xdg-shell-unstable-v6.xml not found in "
-                ${WAYLAND_PROTOCOLS_DATADIR}
-                "\nYour wayland-protocols package does not "
-                "contain xdg-shell-unstable-v6.")
+    if(TARGET openxr-gfxwrapper)
+        # generate wayland protocols
+        set(WAYLAND_PROTOCOLS_DIR ${PROJECT_BINARY_DIR}/wayland-protocols/)
+        file(MAKE_DIRECTORY ${WAYLAND_PROTOCOLS_DIR})
+
+        pkg_get_variable(WAYLAND_PROTOCOLS_DATADIR wayland-protocols pkgdatadir)
+        pkg_get_variable(WAYLAND_SCANNER wayland-scanner wayland_scanner)
+
+        set(PROTOCOL xdg-shell-unstable-v6)
+        set(PROTOCOL_XML ${WAYLAND_PROTOCOLS_DATADIR}/unstable/xdg-shell/${PROTOCOL}.xml)
+
+        if(NOT EXISTS ${PROTOCOL_XML})
+            message(FATAL_ERROR "xdg-shell-unstable-v6.xml not found in " ${WAYLAND_PROTOCOLS_DATADIR}
+                                "\nYour wayland-protocols package does not " "contain xdg-shell-unstable-v6."
+            )
+        endif()
+        add_custom_command(
+            OUTPUT ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c
+            COMMAND ${WAYLAND_SCANNER} code ${PROTOCOL_XML} ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c
+            VERBATIM
+        )
+        add_custom_command(
+            OUTPUT ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h
+            COMMAND ${WAYLAND_SCANNER} client-header ${PROTOCOL_XML} ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h
+            VERBATIM
+        )
+
+        target_sources(openxr-gfxwrapper
+            PRIVATE
+            ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c
+            ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h
+        )
+
+        target_include_directories(openxr-gfxwrapper PUBLIC ${WAYLAND_PROTOCOLS_DIR})
+        target_link_libraries(
+            openxr-gfxwrapper PRIVATE ${EGL_LIBRARIES} ${WAYLAND_CLIENT_LIBRARIES} ${WAYLAND_EGL_LIBRARIES}
+        )
+        target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_WAYLAND)
+        target_link_libraries(openxr-gfxwrapper PRIVATE ${EGL_LIBRARIES} ${WAYLAND_CLIENT_LIBRARIES})
     endif()
 endif()
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
@@ -16,6 +16,10 @@
 #
 
 add_subdirectory(list)
+if(OPENGL_FOUND AND NOT TARGET openxr-gfxwrapper)
+    return()
+endif()
+
 add_subdirectory(hello_xr)
 if(BUILD_LOADER)
 add_subdirectory(loader_test)
diff --git a/src/tests/hello_xr/CMakeLists.txt b/src/tests/hello_xr/CMakeLists.txt
@@ -57,14 +57,11 @@ if(VulkanHeaders_INCLUDE_DIRS)
         ${VulkanHeaders_INCLUDE_DIRS}
     )
 endif()
-if(OPENGL_FOUND)
-    target_sources(hello_xr
-        PRIVATE
-        ${PROJECT_SOURCE_DIR}/src/common/gfxwrapper_opengl.c
-    )
-endif()
 
 target_link_libraries(hello_xr openxr_loader)
+if(TARGET openxr-gfxwrapper)
+    target_link_libraries(hello_xr openxr-gfxwrapper)
+endif()
 if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     if(MSVC)
         target_compile_definitions(hello_xr PRIVATE _CRT_SECURE_NO_WARNINGS)
@@ -73,8 +70,7 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     target_link_libraries(hello_xr d3d11 d3dcompiler dxgi ${OPENGL_gl_LIBRARY})
 elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     target_compile_options(hello_xr PRIVATE -Wall)
-    target_link_libraries(hello_xr m pthread GL ${XLIB_LIBRARIES} ${XCB_LIBRARIES} ${WAYLAND_LIBRARIES})
-    target_sources(hello_xr PRIVATE ${WAYLAND_PROTOCOL_SRC})
+    target_link_libraries(hello_xr m pthread)
 endif()
 
 if(Vulkan_LIBRARY)
diff --git a/src/tests/loader_test/CMakeLists.txt b/src/tests/loader_test/CMakeLists.txt
@@ -18,15 +18,16 @@
 add_executable(loader_test
     loader_test_utils.cpp
     loader_test.cpp
-    ${PROJECT_SOURCE_DIR}/src/common/gfxwrapper_opengl.c
     ${PROJECT_SOURCE_DIR}/src/common/filesystem_utils.cpp
 )
 set_target_properties(loader_test PROPERTIES FOLDER ${TESTS_FOLDER})
 
-add_dependencies(loader_test
-    generate_openxr_header
-)
-target_include_directories(loader_test
+add_dependencies(loader_test generate_openxr_header)
+if(TARGET openxr-gfxwrapper)
+    target_link_libraries(loader_test openxr-gfxwrapper)
+endif()
+target_include_directories(
+    loader_test
     PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
     PRIVATE ${PROJECT_BINARY_DIR}/src
     PRIVATE ${PROJECT_BINARY_DIR}/include
@@ -48,17 +49,7 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
         loader_test PRIVATE -Wall -Wno-unused-function -Wno-format-truncation
     )
 
-    if(PRESENTATION_BACKEND MATCHES "xlib")
-        target_link_libraries(
-            loader_test ${X11_Xxf86vm_LIB} ${X11_Xrandr_LIB} ${X11_LIBRARIES}
-        )
-    elseif(PRESENTATION_BACKEND MATCHES "xcb")
-        target_link_libraries(loader_test ${XCB_LIBRARIES})
-    elseif(PRESENTATION_BACKEND MATCHES "wayland")
-        target_link_libraries(loader_test ${WAYLAND_LIBRARIES})
-        target_sources(loader_test PRIVATE ${WAYLAND_PROTOCOL_SRC})
-    endif()
-    target_link_libraries(loader_test -lstdc++fs openxr_loader m -lpthread GL)
+    target_link_libraries(loader_test -lstdc++fs openxr_loader m -lpthread)
 else()
     message(FATAL_ERROR "Unsupported Platform")
 endif()
