add tools/Vulkan-Tools

1 files changed, 371 insertions, 0 deletions

diff --git a/tools/Vulkan-Tools/cube/CMakeLists.txt b/tools/Vulkan-Tools/cube/CMakeLists.txt
new file mode 100644
index 00000000..7c9b778a
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/CMakeLists.txt
@@ -0,0 +1,371 @@
+# ~~~
+# Copyright (c) 2018 Valve Corporation
+# Copyright (c) 2018 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+if(APPLE)
+    option(APPLE_USE_SYSTEM_ICD "Use system Vulkan ICD discovery instead of bundling MoltenVK" OFF)
+
+    if(APPLE_USE_SYSTEM_ICD)
+        message(STATUS "Using system Vulkan loader for ICD discovery")
+    else()
+        set(MOLTENVK_REPO_ROOT "MOLTENVK-NOTFOUND" CACHE PATH "Absolute path to a MoltenVK repo directory")
+        if(NOT MOLTENVK_REPO_ROOT)
+            message(FATAL_ERROR "Must define location of MoltenVK repo -- see BUILD.md")
+        endif()
+        message(STATUS "Using MoltenVK repo location at ${MOLTENVK_REPO_ROOT}")
+
+        # Source for the MoltenVK ICD library and JSON file
+        set(MOLTENVK_DIR ${MOLTENVK_REPO_ROOT})
+
+        # MoltenVK JSON File
+        execute_process(COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json)
+        execute_process(COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$"
+                                ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json
+                        OUTPUT_FILE ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json)
+
+        # ~~~
+        # Modify the ICD JSON file to adjust the library path.
+        # The ICD JSON file goes in the Resources/vulkan/icd.d directory, so adjust the
+        # library_path to the relative path to the Frameworks directory in the bundle.
+        # The regex does: substitute ':<whitespace>"<whitespace><all occurences of . and />' with:
+        # ': "../../../Frameworks/'
+        # ~~~
+        add_custom_target(MoltenVK_icd-staging-json ALL
+            COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json
+            COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$"
+                    ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json > ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json
+            VERBATIM
+            DEPENDS "${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json"
+        )
+        set_source_files_properties(${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json PROPERTIES GENERATED TRUE)
+    endif()
+
+    find_library(COCOA NAMES Cocoa)
+
+    # Locate Interface Builder Tool, needed to build things like Storyboards outside of Xcode.
+    if(NOT XCODE)
+        # Make sure we can find the 'ibtool' program. If we can NOT find it we skip generation of this project.
+        find_program(IBTOOL ibtool HINTS "/usr/bin" "${OSX_DEVELOPER_ROOT}/usr/bin")
+        if(${IBTOOL} STREQUAL "IBTOOL-NOTFOUND")
+            message(SEND_ERROR "ibtool can not be found and is needed to compile the .xib files. "
+                            "It should have been installed with the Apple developer tools. "
+                            "The default system paths were searched in addition to ${OSX_DEVELOPER_ROOT}/usr/bin.")
+        endif()
+    endif()
+endif()
+
+if(ANDROID OR APPLE)
+    set(WSI_DISPLAY_DEFAULT_SETTING "OFF")
+else()
+    set(WSI_DISPLAY_DEFAULT_SETTING "ON")
+endif()
+
+option(BUILD_WSI_DISPLAY_SUPPORT "Build DISPLAY WSI support" ${WSI_DISPLAY_DEFAULT_SETTING})
+
+if (CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    option(BUILD_WSI_XCB_SUPPORT "Build XCB WSI support" ON)
+    option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" ON)
+    option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" ON)
+    option(BUILD_WSI_DIRECTFB_SUPPORT "Build DirectFB WSI support" OFF)
+
+    find_package(PkgConfig REQUIRED QUIET) # Use PkgConfig to find Linux system libraries
+
+    if(BUILD_WSI_XCB_SUPPORT)
+        pkg_check_modules(XCB REQUIRED QUIET IMPORTED_TARGET xcb)
+        pkg_get_variable(XCB_INCLUDE_DIRS xcb includedir)
+        message(DEBUG "XCB_INCLUDE_DIRS = ${XCB_INCLUDE_DIRS}")
+    endif()
+
+    if(BUILD_WSI_XLIB_SUPPORT)
+        pkg_check_modules(X11 REQUIRED QUIET IMPORTED_TARGET x11)
+        pkg_get_variable(XLIB_INCLUDE_DIRS x11 includedir)
+        message(DEBUG "XLIB_INCLUDE_DIRS = ${XLIB_INCLUDE_DIRS}")
+    endif()
+
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        pkg_check_modules(WAYLAND_CLIENT REQUIRED IMPORTED_TARGET wayland-client)
+        pkg_get_variable(WAYLAND_INCLUDE_DIRS wayland-client includedir)
+
+        pkg_check_modules(WAYLAND_SCANNER REQUIRED wayland-scanner)
+        pkg_get_variable(WAYLAND_SCANNER_EXECUTABLE wayland-scanner wayland_scanner)
+        message(DEBUG "WAYLAND_SCANNER_EXECUTABLE = ${WAYLAND_SCANNER_EXECUTABLE}")
+
+        pkg_get_variable(WAYLAND_CLIENT_PATH wayland-client pkgdatadir)
+        message(DEBUG "WAYLAND_CLIENT_PATH = ${WAYLAND_CLIENT_PATH}")
+        set(WAYLAND_CODE_PROTOCOL ${WAYLAND_CLIENT_PATH}/wayland.xml)
+
+        pkg_check_modules(WAYLAND_PROTOCOLS REQUIRED wayland-protocols)
+        pkg_get_variable(WAYLAND_PROTOCOLS_PATH wayland-protocols pkgdatadir)
+        message(DEBUG "WAYLAND_PROTOCOLS_PATH = ${WAYLAND_PROTOCOLS_PATH}")
+        set(XDG_SHELL_PROTOCOL ${WAYLAND_PROTOCOLS_PATH}/stable/xdg-shell/xdg-shell.xml)
+
+        add_custom_command(COMMENT "Generating wayland client protocol dispatch data"
+                          OUTPUT wayland-client.c
+                          COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                  private-code
+                                  ${WAYLAND_CODE_PROTOCOL}
+                                  ${CMAKE_CURRENT_BINARY_DIR}/wayland-client.c
+                          MAIN_DEPENDENCY ${WAYLAND_CODE_PROTOCOL}
+                          DEPENDS ${WAYLAND_CODE_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+
+        add_custom_command(COMMENT "Generating xdg-shell protocol dispatch data"
+                           OUTPUT xdg-shell-code.c
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   private-code
+                                   ${XDG_SHELL_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-code.c
+                           MAIN_DEPENDENCY ${XDG_SHELL_PROTOCOL}
+                           DEPENDS ${XDG_SHELL_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+        add_custom_command(COMMENT "Generating xdg-shell protocol header"
+                           OUTPUT xdg-shell-client-header.h
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   client-header
+                                   ${XDG_SHELL_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-client-header.h
+                           MAIN_DEPENDENCY ${XDG_SHELL_PROTOCOL}
+                           DEPENDS ${XDG_SHELL_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+
+        set(XDG_DECORATION_PROTOCOL ${WAYLAND_PROTOCOLS_PATH}/unstable/xdg-decoration/xdg-decoration-unstable-v1.xml)
+        add_custom_command(COMMENT "Generating xdg-decoration protocol dispatch data"
+                           OUTPUT xdg-decoration-code.c
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   private-code
+                                   ${XDG_DECORATION_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-code.c
+                           MAIN_DEPENDENCY ${XDG_DECORATION_PROTOCOL}
+                           DEPENDS ${XDG_DECORATION_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+        add_custom_command(COMMENT "Generating xdg-decoration protocol header"
+                           OUTPUT xdg-decoration-client-header.h
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   client-header
+                                   ${XDG_DECORATION_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-client-header.h
+                           MAIN_DEPENDENCY ${XDG_DECORATION_PROTOCOL}
+                           DEPENDS ${XDG_DECORATION_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+
+        set(WAYLAND_ADDITIONAL_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/wayland-client.c
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-code.c
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-client-header.h
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-code.c
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-client-header.h)
+    endif()
+
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        pkg_check_modules(DirectFB REQUIRED QUIET IMPORTED_TARGET directfb)
+    endif()
+endif()
+
+if(BUILD_WSI_DISPLAY_SUPPORT)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_DISPLAY_KHR)
+endif()
+
+if(WIN32)
+    add_definitions(-DWIN32_LEAN_AND_MEAN -DNOMINMAX)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_WIN32_KHR)
+elseif(ANDROID)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_ANDROID_KHR)
+elseif(APPLE)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_METAL_EXT)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    if(BUILD_WSI_XCB_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_XCB_KHR)
+    endif()
+    if(BUILD_WSI_XLIB_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_XLIB_KHR)
+    endif()
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_WAYLAND_KHR)
+    endif()
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_DIRECTFB_EXT)
+    endif()
+    link_libraries(${API_LOWERCASE} m)
+else()
+    message(FATAL_ERROR "Unsupported Platform!")
+endif()
+
+if(NOT DEFINED ENABLED_CUBE_PLATFORMS)
+        message(FATAL_ERROR "There are no supported WSI platforms on this system, vkcube requires a WSI platform be available to be able to render its output")
+endif()
+
+if (COMPILE_CUBE_SHADERS)
+    # Try to find glslang in system paths or in an SDK if the VULKAN_SDK env-var is set
+    find_program(GLSLANG_VALIDATOR names glslang glslangValidator HINTS $ENV{GLSLANG_INSTALL_DIR} $ENV{VULKAN_SDK}/bin $ENV{VULKAN_SDK}/Bin)
+
+    add_custom_command(COMMENT "Compiling cube vertex shader"
+                    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/cube.vert.inc
+                    COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_SOURCE_DIR}/cube.vert.inc
+                            ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                    MAIN_DEPENDENCY ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                    DEPENDS ${PROJECT_SOURCE_DIR}/cube/cube.vert ${GLSLANG_VALIDATOR})
+    add_custom_command(COMMENT "Compiling cube fragment shader"
+                    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/cube.frag.inc
+                    COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_SOURCE_DIR}/cube.frag.inc
+                            ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                    MAIN_DEPENDENCY ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                    DEPENDS ${PROJECT_SOURCE_DIR}/cube/cube.frag ${GLSLANG_VALIDATOR})
+endif()
+
+if(WIN32)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+    # vkcube / vkcube make use of M_PI and various other math defines.
+    add_compile_definitions(_USE_MATH_DEFINES)
+endif()
+
+
+# On Ubuntu 20.04, it was found that the validation layers fail to launch in vkcube & vkcubepp due to
+# a missing dependency on libpthread. While newer Ubuntu versions use a glibc version where libpthread
+# is integrated into libc, older ubuntu's do not so we need to link threads directly in order for
+# validation layers to be loadable.
+if (CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    find_package(Threads REQUIRED)
+endif()
+
+# ----------------------------------------------------------------------------
+# vkcube
+
+if(APPLE)
+    add_subdirectory(macOS/cube)
+elseif (ANDROID)
+    add_library(vkcube MODULE)
+
+    target_sources(vkcube PRIVATE cube.c)
+
+    add_subdirectory(android)
+
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    add_executable(vkcube)
+    target_sources(vkcube PRIVATE
+        cube.c
+        ${PROJECT_SOURCE_DIR}/cube/cube.vert
+        ${PROJECT_SOURCE_DIR}/cube/cube.frag
+        cube.vert.inc
+        cube.frag.inc
+    )
+    target_link_libraries(vkcube  Threads::Threads)
+    if(BUILD_WSI_XCB_SUPPORT)
+        target_sources(vkcube PRIVATE xcb_loader.h)
+        target_include_directories(vkcube PRIVATE ${xcb_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_XLIB_SUPPORT)
+        target_sources(vkcube PRIVATE xlib_loader.h)
+        target_include_directories(vkcube PRIVATE ${XLIB_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        target_include_directories(vkcube PRIVATE ${WAYLAND_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+        target_sources(vkcube PRIVATE PRIVATE ${WAYLAND_ADDITIONAL_SOURCES})
+    endif()
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        target_link_libraries(vkcube PkgConfig::DirectFB)
+    endif()
+    include(CheckLibraryExists)
+    CHECK_LIBRARY_EXISTS("rt" clock_gettime "" NEED_RT)
+    if (NEED_RT)
+        target_link_libraries(vkcube  rt)
+    endif()
+elseif(WIN32)
+    add_executable(vkcube WIN32)
+    target_sources(vkcube PRIVATE
+        cube.c
+        ${PROJECT_SOURCE_DIR}/cube/cube.vert
+        ${PROJECT_SOURCE_DIR}/cube/cube.frag
+        cube.vert.inc
+        cube.frag.inc
+    )
+else()
+    message(FATAL_ERROR "Unsupported Platform!")
+endif()
+
+target_compile_definitions(vkcube PRIVATE ${ENABLED_CUBE_PLATFORMS})
+target_include_directories(vkcube PRIVATE .)
+target_link_libraries(vkcube ${CMAKE_DL_LIBS} Vulkan::Headers)
+
+if (ANDROID)
+    install(TARGETS vkcube DESTINATION ${CMAKE_INSTALL_LIBDIR})
+elseif(APPLE)
+    install(
+        TARGETS vkcube
+        # Install runtime dependencies like the Vulkan::Loader so the app is self-contained
+        RUNTIME_DEPENDENCIES DESTINATION "cube/vkcube.app/Contents/Frameworks/"
+        BUNDLE DESTINATION "cube"
+    )
+    set_target_properties(vkcube PROPERTIES
+        INSTALL_RPATH @executable_path/../Frameworks
+    )
+else()
+    install(TARGETS vkcube)
+endif()
+
+if (ANDROID)
+    return()
+endif()
+
+# ----------------------------------------------------------------------------
+# vkcubepp
+
+if(APPLE)
+    add_subdirectory(macOS/cubepp)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    add_executable(vkcubepp
+                   cube.cpp
+                   ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                   ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                   cube.vert.inc
+                   cube.frag.inc)
+    target_link_libraries(vkcubepp  Threads::Threads)
+
+    if(BUILD_WSI_XCB_SUPPORT)
+        target_sources(vkcubepp PRIVATE xcb_loader.h)
+        target_include_directories(vkcubepp PRIVATE ${xcb_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_XLIB_SUPPORT)
+        target_sources(vkcubepp PRIVATE xlib_loader.h)
+        target_include_directories(vkcubepp PRIVATE ${XLIB_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        target_include_directories(vkcubepp PRIVATE ${WAYLAND_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+        target_sources(vkcubepp PRIVATE ${WAYLAND_ADDITIONAL_SOURCES})
+    endif()
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        target_link_libraries(vkcubepp  PkgConfig::DirectFB)
+    endif()
+else()
+    add_executable(vkcubepp
+                   WIN32
+                   cube.cpp
+                   ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                   ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                   cube.vert.inc
+                   cube.frag.inc)
+endif()
+
+target_include_directories(vkcubepp PRIVATE .)
+target_compile_definitions(vkcubepp PRIVATE ${ENABLED_CUBE_PLATFORMS})
+target_link_libraries(vkcubepp ${CMAKE_DL_LIBS} Vulkan::Headers)
+
+if(APPLE)
+    install(
+        TARGETS vkcubepp
+        # Install runtime dependencies like the Vulkan::Loader so the app is self-contained
+        RUNTIME_DEPENDENCIES DESTINATION "cube/vkcubepp.app/Contents/Frameworks/"
+        BUNDLE DESTINATION "cube"
+    )
+    set_target_properties(vkcubepp PROPERTIES
+        INSTALL_RPATH @executable_path/../Frameworks
+    )
+else()
+    install(TARGETS vkcubepp)
+endif()