diligentcore: add package (#7060)

* diligentcore init

* cl

* diligentcore: test opengl over windows

* Guard mixed static libs into one lib by `NOT(BUILD_SHARED_LIBS)`

* Check against `pkgconf`

* Test for fixed shared build

* Fixup

* try d3d11/12

* try

* `package:add("frameworks", "OpenGL")`

* check metal

* check

* fallbck to opengl

* clear

* `on_install("!bsd and !iphoneos and !android"`

* `format_validation` off

* Enforce `static` build of `Platform/Linux`

* test mingw

* Update xmake.lua

* enforce opengl for os x & enforce `Platform/OSX` static lib

* Init `Archiver` build

* clean up

* Build `Diligent-HLSL2GLSLConverterLib`

* drop `metal`, improve `archive`, limit to win/linux/osx

* improve `archive`

* Test `vulkansdk` on place of `spirv-tools`

* revert

* `archive` follow upstream https://github.com/DiligentGraphics/DiligentCore/commit/8aeec04495b4ed5c6fd44b2de197b3d4f608dd2e https://github.com/DiligentGraphics/DiligentCore/issues/660

* test

* revert test

* Update xmake.lua

* try `shared`

* `package:add("deps", "glslang")`

* `package:add("deps", "spirv-tools")`

* wrap `glslang` package

* Test `vulkan` rendering backend

* remove `package:add("deps", "vulkansdk")`

* Split patch, clean portfile

* fixup

packages/d/diligentcore/patches/v2.5.6/debundle-thirdparty.diff

@@ -0,0 +1,215 @@
+diff --git a/ThirdParty/CMakeLists.txt b/ThirdParty/CMakeLists.txt
+index 00670f0..5486b48 100644
+--- a/ThirdParty/CMakeLists.txt
++++ b/ThirdParty/CMakeLists.txt
+@@ -6,132 +6,48 @@ cmake_minimum_required (VERSION 3.11)
+ # instead:
+ set(CMAKE_POLICY_DEFAULT_CMP0063 NEW)
+ 
+-if (GL_SUPPORTED AND (PLATFORM_WIN32 OR PLATFORM_LINUX OR PLATFORM_MACOS) AND (NOT TARGET GLEW::glew))
+-    add_subdirectory(glew)
+-    if (DILIGENT_INSTALL_CORE)
+-        install(TARGETS glew-static
+-                ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
+-                LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
+-                RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
+-        )
+-    endif()
+-    install(FILES glew/LICENSE.txt DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME GLEW-License.txt)
++include(FindPkgConfig)
++
++if (GL_SUPPORTED AND (PLATFORM_WIN32 OR PLATFORM_LINUX OR PLATFORM_MACOS) AND (NOT glew_FOUND))
++    pkg_check_modules(glew REQUIRED glew)
+ endif()
+ 
+ if (VULKAN_SUPPORTED)
+-    if (NOT TARGET Vulkan::Headers)
+-        # Manually add the Vulkan-Headers target as this is all we need and the
+-        # project's CMake creates unnecessary targets
+-        add_library(Vulkan-Headers INTERFACE)
+-        # Vulkan-Headers_SOURCE_DIR variable is normally created by project(Vulkan-Headers)
+-        set(Vulkan-Headers_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Vulkan-Headers")
+-        add_library(Vulkan::Headers ALIAS Vulkan-Headers)
+-        target_include_directories(Vulkan-Headers INTERFACE "${Vulkan-Headers_SOURCE_DIR}/include")
+-        install(FILES "${Vulkan-Headers_SOURCE_DIR}/LICENSE.md" DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME Vulkan-Headers-License.md)
++    if (NOT vulkan-headers_FOUND)
++        pkg_check_modules(vulkan-headers REQUIRED vulkan-headers)
+     endif()
+ endif()
+ 
+ if (VULKAN_SUPPORTED OR METAL_SUPPORTED OR WEBGPU_SUPPORTED OR (ARCHIVER_SUPPORTED AND (GL_SUPPORTED OR GLES_SUPPORTED)))
+     set(DILIGENT_USE_SPIRV_TOOLCHAIN TRUE CACHE INTERNAL "Use SPIRV Toolchain")
+ 
+-    if (NOT TARGET SPIRV-Headers)
+-        # Manually add the SPIRV-Headers target as this is all we need and the
+-        # project's CMake creates unnecessary install targets
+-        add_library(SPIRV-Headers INTERFACE)
+-        # Note that SPIRV-Headers_SOURCE_DIR variable is normally created by project(SPIRV-Headers)
+-        set(SPIRV-Headers_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/SPIRV-Headers")
+-        target_include_directories(SPIRV-Headers INTERFACE "${SPIRV-Headers_SOURCE_DIR}/include")
+-        install(FILES "${SPIRV-Headers_SOURCE_DIR}/LICENSE" DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME SPIRV-Headers-License.txt)
++    if (NOT SPIRV-Headers_FOUND)
++        pkg_check_modules(SPIRV-Headers REQUIRED SPIRV-Headers)
+     endif()
+ 
+     option(DILIGENT_NO_GLSLANG "Do NOT build glslang compiler" OFF)
+     option(DILIGENT_IMPROVE_SPIRV_TOOLS_DEBUG_PERF "Enable some optimizations for SPIRV-Tools, glslang, SPIRV-Cross and related projects in debug build to improve performance" ON)
+ 
+-    if (NOT (${DILIGENT_NO_GLSLANG} AND ${DILIGENT_NO_HLSL}) AND (NOT TARGET SPIRV-Tools-static))
+-        set(SPIRV_SKIP_TESTS ON CACHE BOOL "Skip SPIRV tests")
+-        set(SPIRV_BUILD_COMPRESSION OFF CACHE BOOL "Do not build SPIRV compressing codec")
+-        set(SPIRV_SKIP_EXECUTABLES ON CACHE BOOL "Skip building SPIRV executable and tests along with the library")
+-        set(SKIP_SPIRV_TOOLS_INSTALL ON CACHE BOOL "Skip SPIRV tools installation")
+-        set(SPIRV_WERROR OFF CACHE BOOL "Do not enable error on warning")
+-        if (${DILIGENT_IMPROVE_SPIRV_TOOLS_DEBUG_PERF})
+-            set(SPIRV_CHECK_CONTEXT OFF CACHE BOOL "Do not check if the IR context is in a valid state")
+-        endif()
+-        set(CMAKE_MACOSX_RPATH TRUE)
+-        add_subdirectory(SPIRV-Tools)
+-        set_directory_root_folder("SPIRV-Tools" "DiligentCore/ThirdParty/SPIRV-Tools")
+-        # We only need SPIRV-Tools-opt for glslang that also depends on SPIRV-Tools-static.
+-        # Exclude all other targets from the build to save build time
+-        set(SPIRV_TOOLS_EXCLUDE_TARGETS SPIRV-Tools-link SPIRV-Tools-lint SPIRV-Tools-reduce SPIRV-Tools-shared)
+-        set_target_properties(${SPIRV_TOOLS_EXCLUDE_TARGETS} PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1)
+-
+-        set(THIRD_PARTY_LIBS SPIRV-Tools-static SPIRV-Tools-opt)
+-        install(FILES "${spirv-tools_SOURCE_DIR}/LICENSE" DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME SPIRV-Tools-License.txt)
++    if (NOT (${DILIGENT_NO_GLSLANG} AND ${DILIGENT_NO_HLSL}) AND (NOT SPIRV-Tools_FOUND))
++        pkg_check_modules(SPIRV-Tools REQUIRED SPIRV-Tools)
+     endif()
+ 
+-    if (NOT ${DILIGENT_NO_GLSLANG} AND (NOT TARGET glslang))
+-        set(ENABLE_GLSLANG_BINARIES OFF CACHE BOOL "Do not build glslang binaries")
+-        set(ENABLE_SPVREMAPPER OFF CACHE BOOL "Do not build SPIRV remapper")
+-        set(SKIP_GLSLANG_INSTALL ON CACHE BOOL "Skip glslang installation")
+-        set(ENABLE_CTEST OFF CACHE BOOL "Disable testing")
+-        if (PLATFORM_EMSCRIPTEN)
+-            # Optimization has to be disabled on Web, see build instructions on https://github.com/KhronosGroup/glslang
+-            set(ENABLE_OPT OFF)
+-        endif()
+-        add_subdirectory(glslang)
+-        set_directory_root_folder("glslang" "DiligentCore/ThirdParty/glslang")
+-
+-        if (PLATFORM_EMSCRIPTEN)
+-             set_targets_emscripten_properties(MachineIndependent)
+-        endif()
+-
+-        # glslang "kindly" sets global CMAKE_DEBUG_POSTFIX to "d", which we have to unset now
+-        unset(CMAKE_DEBUG_POSTFIX CACHE)
+-
+-        list(APPEND THIRD_PARTY_LIBS GenericCodeGen glslang OSDependent SPIRV MachineIndependent)
+-        install(FILES "${glslang_SOURCE_DIR}/LICENSE.txt" DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME GLSLang-License.txt)
++    if (NOT ${DILIGENT_NO_GLSLANG} AND (NOT glslang_FOUND))
++        pkg_check_modules(glslang REQUIRED glslang)
+     endif()
+ 
+-    if (NOT TARGET spirv-cross-core)
+-        set(SPIRV_CROSS_CLI OFF CACHE BOOL "Build the CLI binary. Requires SPIRV_CROSS_STATIC.")
+-        set(SPIRV_CROSS_ENABLE_TESTS OFF CACHE BOOL "Enable SPIRV-Cross tests.")
+-        set(SPIRV_CROSS_ENABLE_MSL ${METAL_SUPPORTED} CACHE BOOL "Enable MSL target support.")
+-        # MSL support requires GLSL
+-        if (${SPIRV_CROSS_ENABLE_MSL} OR ${GL_SUPPORTED} OR ${GLES_SUPPORTED})
+-            set(SPIRV_CROSS_ENABLE_GLSL TRUE CACHE BOOL "Enable GLSL support.")
+-        else()
+-            set(SPIRV_CROSS_ENABLE_GLSL OFF CACHE BOOL "Enable GLSL support.")
+-        endif()
+-        set(SPIRV_CROSS_ENABLE_HLSL OFF CACHE BOOL "Enable HLSL target support.")
+-        set(SPIRV_CROSS_ENABLE_CPP OFF CACHE BOOL "Enable C++ target support.")
+-        set(SPIRV_CROSS_ENABLE_REFLECT OFF CACHE BOOL "Enable JSON reflection target support.")
+-        set(SPIRV_CROSS_ENABLE_C_API OFF CACHE BOOL "Enable C API wrapper support in static library.")
+-        set(SPIRV_CROSS_ENABLE_UTIL OFF CACHE BOOL "Enable util module support.")
+-        set(SPIRV_CROSS_FORCE_PIC ON CACHE BOOL "Force position-independent code.")
+-        set(SPIRV_CROSS_SKIP_INSTALL ON CACHE BOOL "Skip SPIRV-Cross installation.")
+-        set(SPIRV_CROSS_NAMESPACE_OVERRIDE diligent_spirv_cross CACHE STRING "Override the namespace used in the C++ API.")
+-        add_subdirectory(SPIRV-Cross)
+-        set_directory_root_folder("SPIRV-Cross" "DiligentCore/ThirdParty/SPIRV-Cross")
+-
+-        list(APPEND THIRD_PARTY_LIBS spirv-cross-core)
+-        if(SPIRV_CROSS_ENABLE_GLSL)
+-            list(APPEND THIRD_PARTY_LIBS spirv-cross-glsl)
+-        endif()
+-        if (SPIRV_CROSS_ENABLE_MSL)
+-            list(APPEND THIRD_PARTY_LIBS spirv-cross-msl)
+-        endif()
+-
+-        install(FILES "${SPIRV-Cross_SOURCE_DIR}/LICENSE" DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME SPIRV-Cross-License.txt)
++    if (NOT spirv-cross-c_FOUND)
++        pkg_check_modules(spirv-cross-c REQUIRED spirv-cross-c)
+     endif()
+ 
+-    if (DILIGENT_INSTALL_CORE)
++    if (0)
+         install(TARGETS ${THIRD_PARTY_LIBS}
+-                ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
+-                LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
+-                RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
++                ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
++                LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
++                RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+         )
+     endif()
+-
+-    if (MSVC)
++    if (0)
+         foreach(TARGET ${THIRD_PARTY_LIBS}) 
+             if (${DILIGENT_IMPROVE_SPIRV_TOOLS_DEBUG_PERF})
+                 # Enable function inlining (/Ob1) in Debug build to improve shader compilation performance
+@@ -144,34 +60,21 @@ if (VULKAN_SUPPORTED OR METAL_SUPPORTED OR WEBGPU_SUPPORTED OR (ARCHIVER_SUPPORT
+         endforeach()
+     endif()
+ 
+-    # Make sure that symbols do not leak out when third-party
+-    # libs are linked into shared libraries
+-    set_target_properties(${THIRD_PARTY_LIBS} PROPERTIES
+-        CXX_VISIBILITY_PRESET hidden # -fvisibility=hidden
+-        C_VISIBILITY_PRESET hidden # -fvisibility=hidden
+-        VISIBILITY_INLINES_HIDDEN TRUE
+-     )
+ else()
+     set(DILIGENT_USE_SPIRV_TOOLCHAIN FALSE CACHE INTERNAL "")
+ endif()
+ 
+-if (VULKAN_SUPPORTED AND (PLATFORM_WIN32 OR PLATFORM_LINUX OR PLATFORM_MACOS OR PLATFORM_ANDROID) AND (NOT TARGET volk::volk_headers))
+-    set(VOLK_PULL_IN_VULKAN OFF)
+-    set(VOLK_INSTALL OFF)
+-    set(VOLK_HEADERS_ONLY ON)
+-    add_subdirectory(volk)
+-    install(FILES "${volk_SOURCE_DIR}/LICENSE.md" DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME Volk-License.md)
++if (VULKAN_SUPPORTED AND (PLATFORM_WIN32 OR PLATFORM_LINUX OR PLATFORM_MACOS OR PLATFORM_ANDROID) AND (NOT volk_FOUND))
++    pkg_check_modules(volk REQUIRED volk)
+ endif()
+ 
+-if (WEBGPU_SUPPORTED)
+-    add_subdirectory(abseil-cpp EXCLUDE_FROM_ALL)
+-    set_directory_root_folder("abseil-cpp" "DiligentCore/ThirdParty")
++if (WEBGPU_SUPPORTED AND ((NOT abseil_FOUND) OR (NOT dawn_FOUND)))
++    pkg_check_modules(abseil REQUIRED abseil)
+ 
+-    add_subdirectory(dawn EXCLUDE_FROM_ALL)
+-    set_directory_root_folder("dawn" "DiligentCore/ThirdParty/dawn")
++    pkg_check_modules(dawn REQUIRED dawn)
+ endif()
+ 
+-if ((${DILIGENT_BUILD_GOOGLE_TEST}) AND (NOT TARGET gtest))
++if (0)
+     set(INSTALL_GTEST OFF CACHE BOOL "Do not install googletest")
+     set(BUILD_GMOCK OFF CACHE BOOL "Do not build gmock")
+     set(gtest_force_shared_crt ON CACHE BOOL "Use shared (DLL) run-time lib even when Google Test is built as static lib.")
+@@ -192,15 +95,7 @@ if ((${DILIGENT_BUILD_GOOGLE_TEST}) AND (NOT TARGET gtest))
+     endif()
+ endif()
+ 
+-if (NOT TARGET xxHash::xxhash)
+-    option(BUILD_SHARED_LIBS "Build shared library" OFF)
+-    set(XXHASH_BUILD_XXHSUM OFF)
+-    set(XXHASH_BUILD_ENABLE_INLINE_API OFF)
+-    add_subdirectory(xxHash/cmake_unofficial)
+-    set_directory_root_folder("xxHash/cmake_unofficial" "DiligentCore/ThirdParty/xxHash")
+-    install(FILES "${xxHash_SOURCE_DIR}/../LICENSE" DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME xxHash-License.txt)
++if (NOT XXHASH_FOUND)
++    pkg_check_modules(XXHASH REQUIRED libxxhash)
+ endif()
+ 
+-install(FILES stb/stb_image_write_license.txt DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}")
+-install(FILES DirectXShaderCompiler/LICENSE.TXT DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME DXC-License.txt)
+-install(FILES DirectXShaderCompiler/ThirdPartyNotices.txt DESTINATION "Licenses/ThirdParty/${DILIGENT_CORE_DIR}" RENAME DXC-ThirdPartyNotices.txt)

packages/d/diligentcore/patches/v2.5.6/enforce-static-lib-type-for-platform-libraries.diff

@@ -0,0 +1,52 @@
+diff --git a/Platforms/Apple/CMakeLists.txt b/Platforms/Apple/CMakeLists.txt
+index d43c57e..d59c96a 100644
+--- a/Platforms/Apple/CMakeLists.txt
++++ b/Platforms/Apple/CMakeLists.txt
+@@ -30,7 +30,7 @@ if(PLATFORM_MACOS)
+ 	list(APPEND SOURCE src/MacOSNativeWindow.mm)
+ endif()
+ 
+-add_library(Diligent-ApplePlatform ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
++add_library(Diligent-ApplePlatform STATIC ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
+ set_common_target_properties(Diligent-ApplePlatform)
+ 
+ target_include_directories(Diligent-ApplePlatform
+diff --git a/Platforms/Linux/CMakeLists.txt b/Platforms/Linux/CMakeLists.txt
+index 347d798..edbe801 100644
+--- a/Platforms/Linux/CMakeLists.txt
++++ b/Platforms/Linux/CMakeLists.txt
+@@ -16,7 +16,7 @@ set(SOURCE
+     src/LinuxPlatformMisc.cpp
+ )
+ 
+-add_library(Diligent-LinuxPlatform ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
++add_library(Diligent-LinuxPlatform STATIC ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
+ set_common_target_properties(Diligent-LinuxPlatform)
+ 
+ target_include_directories(Diligent-LinuxPlatform
+diff --git a/Platforms/UWP/CMakeLists.txt b/Platforms/UWP/CMakeLists.txt
+index f610f71..9987733 100644
+--- a/Platforms/UWP/CMakeLists.txt
++++ b/Platforms/UWP/CMakeLists.txt
+@@ -14,7 +14,7 @@ set(SOURCE
+     src/UWPFileSystem.cpp
+ )
+ 
+-add_library(Diligent-UniversalWindowsPlatform ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
++add_library(Diligent-UniversalWindowsPlatform STATIC ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
+ set_common_target_properties(Diligent-UniversalWindowsPlatform)
+ 
+ target_include_directories(Diligent-UniversalWindowsPlatform
+diff --git a/Platforms/Win32/CMakeLists.txt b/Platforms/Win32/CMakeLists.txt
+index 5ef3acb..d55f41f 100644
+--- a/Platforms/Win32/CMakeLists.txt
++++ b/Platforms/Win32/CMakeLists.txt
+@@ -16,7 +16,7 @@ set(SOURCE
+     src/Win32PlatformMisc.cpp
+ )
+ 
+-add_library(Diligent-Win32Platform ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
++add_library(Diligent-Win32Platform STATIC ${SOURCE} ${INTERFACE} ${PLATFORM_INTERFACE_HEADERS})
+ set_common_target_properties(Diligent-Win32Platform)
+ 
+ target_include_directories(Diligent-Win32Platform

packages/d/diligentcore/patches/v2.5.6/fix-build-deps-pkgconf.diff

@@ -0,0 +1,351 @@
+diff --git a/Graphics/Archiver/CMakeLists.txt b/Graphics/Archiver/CMakeLists.txt
+index 6af0f44..2077ff7 100644
+--- a/Graphics/Archiver/CMakeLists.txt
++++ b/Graphics/Archiver/CMakeLists.txt
+@@ -88,9 +88,16 @@ PRIVATE
+     ../GraphicsEngineNextGenBase/include
+ )
+ 
++if (NOT DILIGENT_NO_GLSLANG)
++    target_include_directories(Diligent-Archiver-static
++    PRIVATE
++        ${spirv-cross-c_INCLUDEDIR}
++    )
++endif()
++
+ target_compile_definitions(Diligent-Archiver-static
+ PRIVATE
+-    DILIGENT_NO_GLSLANG=$<BOOL:$<NOT:$<TARGET_EXISTS:glslang>>>
++    DILIGENT_NO_GLSLANG=$<BOOL:${DILIGENT_NO_GLSLANG}>
+ )
+ if(DEFINED DILIGENT_CORE_COMMIT_HASH)
+     target_compile_definitions(Diligent-Archiver-static PRIVATE DILIGENT_CORE_COMMIT_HASH="${DILIGENT_CORE_COMMIT_HASH}")
+@@ -121,10 +128,11 @@ if(D3D12_SUPPORTED)
+ endif()
+ 
+ if(VULKAN_SUPPORTED)
+-    target_link_libraries(Diligent-Archiver-static PRIVATE Diligent-GraphicsEngineVk-static Vulkan::Headers)
++    target_link_libraries(Diligent-Archiver-static PRIVATE Diligent-GraphicsEngineVk-static)
+     target_include_directories(Diligent-Archiver-static
+     PRIVATE
+         ../GraphicsEngineVulkan/include
++        ${vulkan-headers_INCLUDEDIR}
+     )
+ endif()
+ 
+@@ -135,17 +143,18 @@ if(GL_SUPPORTED OR GLES_SUPPORTED)
+         spirv-cross-core
+         spirv-cross-glsl
+     )
+-    target_include_directories(Diligent-Archiver-static PRIVATE ../GraphicsEngineOpenGL/include)
++    target_include_directories(Diligent-Archiver-static PRIVATE ../GraphicsEngineOpenGL/include ${glew_INCLUDE_DIRS})
+ 
+     if(PLATFORM_WIN32)
+-        target_link_libraries(Diligent-Archiver-static PRIVATE GLEW::glew opengl32.lib)
++        target_link_directories(Diligent-Archiver-static PRIVATE ${glew_LIBRARY_DIRS})
++        target_link_libraries(Diligent-Archiver-static PRIVATE ${glew_LIBRARIES})
+     elseif(PLATFORM_LINUX)
+         find_package(X11 REQUIRED)
+-        find_package(OpenGL REQUIRED)
+-        target_link_libraries(Diligent-Archiver-static PRIVATE GLEW::glew OpenGL::GL X11::X11)
++        target_link_directories(Diligent-Archiver-static PRIVATE ${glew_LIBRARY_DIRS})
++        target_link_libraries(Diligent-Archiver-static PRIVATE ${glew_LIBRARIES} X11::X11)
+     elseif(PLATFORM_MACOS)
+-        find_package(OpenGL REQUIRED)
+-        target_link_libraries(Diligent-Archiver-static PRIVATE GLEW::glew OpenGL::GL)
++        target_link_directories(Diligent-Archiver-static PRIVATE ${glew_LIBRARY_DIRS})
++        target_link_libraries(Diligent-Archiver-static PRIVATE ${glew_LIBRARIES} "-framework OpenGL")
+     elseif(PLATFORM_ANDROID)
+         target_link_libraries(Diligent-Archiver-static PRIVATE GLESv3 EGL)
+     elseif(PLATFORM_EMSCRIPTEN)
+@@ -176,12 +185,28 @@ if(WEBGPU_SUPPORTED)
+     )
+ endif()
+ 
++if (glew_FOUND)
++    target_link_directories(Diligent-Archiver-shared PRIVATE ${glew_LIBRARY_DIRS})
++endif()
++
++if(spirv-cross-c_FOUND)
++    target_link_directories(Diligent-Archiver-shared PRIVATE ${spirv-cross-c_LIBDIR})
++endif()
++
++if(glslang_FOUND)
++    target_link_directories(Diligent-Archiver-shared PRIVATE ${glslang_LIBDIR})
++endif()
++
++if (NOT DILIGENT_NO_GLSLANG)
++    target_link_directories(Diligent-Archiver-shared PRIVATE ${SPIRV-Tools_LIBDIR})
++endif()
++
+ target_link_libraries(Diligent-Archiver-shared
+ PUBLIC
+     Diligent-ArchiverInterface
+ PRIVATE
+     Diligent-BuildSettings
+-    ${WHOLE_ARCHIVE_FLAG} Diligent-Archiver-static ${NO_WHOLE_ARCHIVE_FLAG}
++    ${WHOLE_ARCHIVE_FLAG} Diligent-Archiver-static ${NO_WHOLE_ARCHIVE_FLAG} $<$<NOT:$<BOOL:${DILIGENT_NO_GLSLANG}>>:${SPIRV-Tools_LIBRARIES}>
+ )
+ 
+ if(PLATFORM_WIN32)
+diff --git a/Graphics/GraphicsEngineD3D11/CMakeLists.txt b/Graphics/GraphicsEngineD3D11/CMakeLists.txt
+index adef784..75944e8 100644
+--- a/Graphics/GraphicsEngineD3D11/CMakeLists.txt
++++ b/Graphics/GraphicsEngineD3D11/CMakeLists.txt
+@@ -136,6 +136,18 @@ PUBLIC
+     Diligent-GraphicsEngineD3D11Interface
+ )
+ 
++if(SPIRV-Tools_FOUND)
++    target_link_directories(Diligent-GraphicsEngineD3D11-shared PRIVATE ${SPIRV-Tools_LIBDIR})
++endif()
++
++if(spirv-cross-c_FOUND)
++    target_link_directories(Diligent-GraphicsEngineD3D11-shared PRIVATE ${spirv-cross-c_LIBRARY_DIRS})
++endif()
++
++if(glslang_FOUND)
++    target_link_directories(Diligent-GraphicsEngineD3D11-shared PRIVATE ${glslang_LIBDIR})
++endif()
++
+ target_link_libraries(Diligent-GraphicsEngineD3D11-shared
+ PRIVATE
+     Diligent-BuildSettings 
+diff --git a/Graphics/GraphicsEngineD3D12/CMakeLists.txt b/Graphics/GraphicsEngineD3D12/CMakeLists.txt
+index 4b01eff..868e627 100644
+--- a/Graphics/GraphicsEngineD3D12/CMakeLists.txt
++++ b/Graphics/GraphicsEngineD3D12/CMakeLists.txt
+@@ -206,6 +206,18 @@ if(NOT ${USE_D3D12_LOADER})
+     target_link_libraries(Diligent-GraphicsEngineD3D12-static PRIVATE d3d12.lib)
+ endif()
+ 
++if(SPIRV-Tools_FOUND)
++    target_link_directories(Diligent-GraphicsEngineD3D12-shared PRIVATE ${SPIRV-Tools_LIBDIR})
++endif()
++
++if(spirv-cross-c_FOUND)
++    target_link_directories(Diligent-GraphicsEngineD3D12-shared PRIVATE ${spirv-cross-c_LIBRARY_DIRS})
++endif()
++
++if(glslang_FOUND)
++    target_link_directories(Diligent-GraphicsEngineD3D12-shared PRIVATE ${glslang_LIBDIR})
++endif()
++
+ target_link_libraries(Diligent-GraphicsEngineD3D12-shared
+ PRIVATE
+     Diligent-BuildSettings
+diff --git a/Graphics/GraphicsEngineOpenGL/CMakeLists.txt b/Graphics/GraphicsEngineOpenGL/CMakeLists.txt
+index 839dad7..c544296 100644
+--- a/Graphics/GraphicsEngineOpenGL/CMakeLists.txt
++++ b/Graphics/GraphicsEngineOpenGL/CMakeLists.txt
+@@ -175,6 +175,7 @@ endif()
+ target_include_directories(Diligent-GraphicsEngineOpenGL-static
+ PRIVATE
+     include
++    ${glew_INCLUDE_DIRS}
+ )
+ 
+ set(PRIVATE_DEPENDENCIES
+@@ -198,16 +199,17 @@ set(PUBLIC_DEPENDENCIES
+ )
+ 
+ if(PLATFORM_WIN32)
+-    set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} GLEW::glew opengl32.lib)
++    target_link_directories(Diligent-GraphicsEngineOpenGL-static PRIVATE ${glew_LIBRARY_DIRS})
++    set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} ${glew_LIBRARIES})
+ elseif(PLATFORM_ANDROID)
+     set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} GLESv3 EGL)
+ elseif(PLATFORM_LINUX)
+     find_package(X11 REQUIRED)
+-    find_package(OpenGL REQUIRED)
+-    set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} GLEW::glew OpenGL::GL X11::X11)
++    target_link_directories(Diligent-GraphicsEngineOpenGL-static PRIVATE ${glew_LIBRARY_DIRS})
++    set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} ${glew_LIBRARIES} X11::X11)
+ elseif(PLATFORM_MACOS)
+-    find_package(OpenGL REQUIRED)
+-    set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} GLEW::glew OpenGL::GL)
++    target_link_directories(Diligent-GraphicsEngineOpenGL-static PRIVATE ${glew_LIBRARY_DIRS})
++    set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} ${glew_LIBRARIES} "-framework OpenGL")
+ elseif(PLATFORM_IOS)
+     set(PRIVATE_DEPENDENCIES ${PRIVATE_DEPENDENCIES} ${OPENGLES})
+ elseif(PLATFORM_EMSCRIPTEN)
+@@ -264,6 +266,19 @@ PUBLIC
+     ${PUBLIC_DEPENDENCIES}
+ )
+ 
++if(SPIRV-Tools_FOUND)
++    target_link_directories(Diligent-GraphicsEngineOpenGL-shared PRIVATE ${SPIRV-Tools_LIBDIR})
++endif()
++
++if(spirv-cross-c_FOUND)
++    target_link_directories(Diligent-GraphicsEngineOpenGL-shared PRIVATE ${spirv-cross-c_LIBRARY_DIRS})
++endif()
++
++if(glslang_FOUND)
++    target_link_directories(Diligent-GraphicsEngineOpenGL-shared PRIVATE ${glslang_LIBDIR})
++endif()
++
++target_link_directories(Diligent-GraphicsEngineOpenGL-shared PRIVATE ${glew_LIBRARY_DIRS})
+ target_compile_definitions(Diligent-GraphicsEngineOpenGL-shared PUBLIC ENGINE_DLL=1)
+ if(PLATFORM_MACOS)
+     # Silence OpenGL deprecation warnings
+diff --git a/Graphics/GraphicsEngineVulkan/CMakeLists.txt b/Graphics/GraphicsEngineVulkan/CMakeLists.txt
+index 9d45358..fb650ee 100644
+--- a/Graphics/GraphicsEngineVulkan/CMakeLists.txt
++++ b/Graphics/GraphicsEngineVulkan/CMakeLists.txt
+@@ -164,15 +164,19 @@ endif()
+ target_include_directories(Diligent-GraphicsEngineVk-static
+ PRIVATE
+     include
++    ${vulkan-headers_INCLUDEDIR}
+ )
+ 
++if (SPIRV-Tools_FOUND)
++    target_include_directories(Diligent-GraphicsEngineVk-static PRIVATE ${SPIRV-Tools_INCLUDEDIR})
++endif()
++
+ set(PRIVATE_DEPENDENCIES
+     Diligent-BuildSettings
+     Diligent-Common
+     Diligent-TargetPlatform
+     Diligent-GraphicsEngineNextGenBase
+     Diligent-ShaderTools
+-    Vulkan::Headers
+ )
+ 
+ if (${DILIGENT_NO_HLSL})
+@@ -246,9 +250,9 @@ else()
+ endif()
+ 
+ if(PLATFORM_WIN32)
+-    list(APPEND PRIVATE_DEPENDENCIES volk::volk_headers)
++    target_include_directories(Diligent-GraphicsEngineVk-static PRIVATE ${volk_INCLUDEDIR})
+ elseif(PLATFORM_MACOS)
+-    list(APPEND PRIVATE_DEPENDENCIES volk::volk_headers)
++    target_include_directories(Diligent-GraphicsEngineVk-static PRIVATE ${volk_INCLUDEDIR})
+ elseif(PLATFORM_IOS OR PLATFORM_TVOS)
+     find_library(CORE_GRAPHICS CoreGraphics)
+     find_library(METAL_LIBRARY Metal)
+@@ -258,9 +262,9 @@ elseif(PLATFORM_IOS OR PLATFORM_TVOS)
+     # Note that volk may be defined by external CMake, but we don't use it on iOS/tvOS
+     list(APPEND PRIVATE_DEPENDENCIES ${MOLTENVK_LIBRARY} ${CORE_GRAPHICS} ${METAL_LIBRARY} ${QUARTZ_CORE} ${UI_KIT} ${IO_SURFACE})
+ elseif(PLATFORM_LINUX)
+-    list(APPEND PRIVATE_DEPENDENCIES volk::volk_headers)
++    target_include_directories(Diligent-GraphicsEngineVk-static PRIVATE ${volk_INCLUDEDIR})
+ elseif(PLATFORM_ANDROID)
+-    list(APPEND PRIVATE_DEPENDENCIES volk::volk_headers)
++    target_include_directories(Diligent-GraphicsEngineVk-static PRIVATE ${volk_INCLUDEDIR})
+ else()
+     find_library(Vulkan_LIBRARY NAMES vulkan)
+     list(APPEND PRIVATE_DEPENDENCIES ${Vulkan_LIBRARY})
+@@ -311,6 +315,19 @@ if (${DILIGENT_NO_GLSLANG})
+     message("GLSLang is not being built. Vulkan backend will only be able to consume SPIRV byte code.")
+ endif()
+ 
++if(SPIRV-Tools_FOUND)
++    target_link_directories(Diligent-GraphicsEngineVk-shared PRIVATE ${SPIRV-Tools_LIBDIR})
++    target_link_libraries(Diligent-GraphicsEngineVk-shared PRIVATE SPIRV-Tools-opt SPIRV-Tools)
++endif()
++
++if(spirv-cross-c_FOUND)
++    target_link_directories(Diligent-GraphicsEngineVk-shared PRIVATE ${spirv-cross-c_LIBRARY_DIRS})
++endif()
++
++if(glslang_FOUND)
++    target_link_directories(Diligent-GraphicsEngineVk-shared PRIVATE ${glslang_LIBDIR})
++endif()
++
+ target_compile_definitions(Diligent-GraphicsEngineVk-static
+ PRIVATE
+     ${PRIVATE_COMPILE_DEFINITIONS}
+diff --git a/Graphics/GraphicsTools/CMakeLists.txt b/Graphics/GraphicsTools/CMakeLists.txt
+index c7f8706..bb9e94a 100644
+--- a/Graphics/GraphicsTools/CMakeLists.txt
++++ b/Graphics/GraphicsTools/CMakeLists.txt
+@@ -88,7 +88,7 @@ if(D3D12_SUPPORTED)
+ endif()
+ 
+ if(VULKAN_SUPPORTED)
+-    list(APPEND DEPENDENCIES Diligent-GraphicsEngineVkInterface Vulkan::Headers)
++    list(APPEND DEPENDENCIES Diligent-GraphicsEngineVkInterface)
+ endif()
+ 
+ if(D3D12_SUPPORTED OR VULKAN_SUPPORTED)
+@@ -122,10 +122,15 @@ target_include_directories(Diligent-GraphicsTools
+ PUBLIC
+     interface
+ PRIVATE
++    ${XXHASH_INCLUDE_DIRS}
+     ../GraphicsEngineD3DBase/include
+     include
+ )
+ 
++if(VULKAN_SUPPORTED)
++    target_include_directories(Diligent-GraphicsTools PRIVATE ${vulkan-headers_INCLUDEDIR})
++endif()
++
+ target_link_libraries(Diligent-GraphicsTools
+ PRIVATE
+     Diligent-Common
+@@ -134,7 +139,7 @@ PRIVATE
+     Diligent-GraphicsAccessories
+     Diligent-ShaderTools
+     Diligent-GraphicsEngine
+-    xxHash::xxhash
++    ${XXHASH_LIBRARIES}
+     ${DEPENDENCIES}
+ PUBLIC
+     Diligent-GraphicsEngineInterface
+diff --git a/Graphics/ShaderTools/CMakeLists.txt b/Graphics/ShaderTools/CMakeLists.txt
+index bf956ea..42bf3be 100644
+--- a/Graphics/ShaderTools/CMakeLists.txt
++++ b/Graphics/ShaderTools/CMakeLists.txt
+@@ -102,11 +102,11 @@ if(DILIGENT_USE_SPIRV_TOOLCHAIN)
+     #     (e.g. added by external project), but DILIGENT_NO_GLSLANG may still be set
+     if (NOT ${DILIGENT_NO_GLSLANG})
+         set(USE_GLSLANG TRUE)
+-        if (TARGET SPIRV-Tools-opt)
++        if (SPIRV-Tools_FOUND)
+             set(USE_SPIRV_TOOLS TRUE)
+         endif()
+     endif()
+-    if (NOT ${DILIGENT_NO_HLSL} AND TARGET SPIRV-Tools-opt)
++    if (NOT ${DILIGENT_NO_HLSL})
+         set(USE_SPIRV_TOOLS TRUE)
+     endif()
+ endif()
+@@ -133,6 +133,10 @@ PUBLIC
+     include
+ PRIVATE
+     ../GraphicsEngine/include
++    $<$<BOOL:${ENABLE_SPIRV}>:${spirv-cross-c_INCLUDEDIR}>
++    $<$<BOOL:${USE_GLSLANG}>:${glslang_INCLUDEDIR}>
++    $<$<BOOL:${USE_GLSLANG}>:${glslang_INCLUDEDIR}/glslang>
++    $<$<BOOL:${USE_SPIRV_TOOLS}>:${SPIRV-Tools_INCLUDEDIR}>
+ )
+ 
+ if (DXC_SUPPORTED)
+@@ -150,6 +154,12 @@ if (DXC_SUPPORTED)
+     endif()
+ endif()
+ 
++target_link_directories(Diligent-ShaderTools
++PRIVATE
++    $<$<BOOL:${ENABLE_SPIRV}>:${spirv-cross-c_LIBDIR}>
++    $<$<BOOL:${USE_GLSLANG}>:${glslang_LIBDIR}>
++)
++
+ target_link_libraries(Diligent-ShaderTools
+ PRIVATE
+     Diligent-BuildSettings
+@@ -171,9 +181,7 @@ if(ENABLE_SPIRV)
+     PRIVATE
+         spirv-cross-core
+     )
+-    if(SPIRV_CROSS_NAMESPACE_OVERRIDE)
+-        target_compile_definitions(Diligent-ShaderTools PUBLIC DILIGENT_SPIRV_CROSS_NAMESPACE=${SPIRV_CROSS_NAMESPACE_OVERRIDE})
+-    endif()
++        target_compile_definitions(Diligent-ShaderTools PUBLIC DILIGENT_SPIRV_CROSS_NAMESPACE=spirv_cross)
+ 
+     if (${USE_SPIRV_TOOLS})
+         target_link_libraries(Diligent-ShaderTools

packages/d/diligentcore/patches/v2.5.6/fix-install-path.diff

@@ -0,0 +1,52 @@
+diff --git a/BuildTools/CMake/BuildUtils.cmake b/BuildTools/CMake/BuildUtils.cmake
+index e97b96b..bf9d26e 100644
+--- a/BuildTools/CMake/BuildUtils.cmake
++++ b/BuildTools/CMake/BuildUtils.cmake
+@@ -292,14 +292,22 @@ function(install_core_lib _TARGET)
+     if(TARGET_TYPE STREQUAL STATIC_LIBRARY)
+         list(APPEND DILIGENT_CORE_INSTALL_LIBS_LIST ${_TARGET})
+         set(DILIGENT_CORE_INSTALL_LIBS_LIST ${DILIGENT_CORE_INSTALL_LIBS_LIST} CACHE INTERNAL "Core libraries installation list")
++        install(TARGETS                 ${_TARGET}
++                ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
++                LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
++                RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
++        )
++        if (DILIGENT_INSTALL_PDB)
++            install(FILES $<TARGET_PDB_FILE:${_TARGET}> DESTINATION "${CMAKE_INSTALL_BINDIR}" OPTIONAL)
++        endif()
+     elseif(TARGET_TYPE STREQUAL SHARED_LIBRARY)
+         install(TARGETS                 ${_TARGET}
+-                ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
+-                LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
+-                RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"
++                ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
++                LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
++                RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+         )
+         if (DILIGENT_INSTALL_PDB)
+-            install(FILES $<TARGET_PDB_FILE:${_TARGET}> DESTINATION "${CMAKE_INSTALL_BINDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>" OPTIONAL)
++            install(FILES $<TARGET_PDB_FILE:${_TARGET}> DESTINATION "${CMAKE_INSTALL_BINDIR}" OPTIONAL)
+         endif()
+     endif()
+ 
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index fc3c5d8..9edc6a4 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -614,7 +614,6 @@ add_subdirectory(Primitives)
+ add_subdirectory(Platforms)
+ add_subdirectory(Common)
+ add_subdirectory(Graphics)
+-add_subdirectory(Tests)
+ 
+ 
+ # Installation instructions
+@@ -625,7 +624,7 @@ if(DILIGENT_INSTALL_CORE)
+         "${DILIGENT_CORE_INSTALL_LIBS_LIST}"
+         DiligentCore-static                     # Custom target name
+         DiligentCore                            # Folder
+-        "${CMAKE_INSTALL_LIBDIR}/${DILIGENT_CORE_DIR}/$<CONFIG>"    # Install destination
++        "${CMAKE_INSTALL_LIBDIR}"    # Install destination
+     )
+ 
+     install(FILES License.txt DESTINATION "Licenses" RENAME DiligentEngine-License.txt)

packages/d/diligentcore/patches/v2.5.6/fix-spirv-cross-namespace.diff

@@ -0,0 +1,45 @@
+diff --git a/Graphics/Archiver/src/Archiver_GL.cpp b/Graphics/Archiver/src/Archiver_GL.cpp
+index a7435c9..86d7223 100644
+--- a/Graphics/Archiver/src/Archiver_GL.cpp
++++ b/Graphics/Archiver/src/Archiver_GL.cpp
+@@ -420,7 +420,8 @@ private:
+         Bool          IsES = false;
+         GetGLSLVersion(ShaderCI, TargetGLSLCompiler::driver, DeviceType, GLShaderCI.DeviceInfo.MaxShaderVersion, GLSLVersion, IsES);
+ 
+-        diligent_spirv_cross::CompilerGLSL::Options Options;
++        using CompilerGLSL = SPIRV_CROSS_NAMESPACE::CompilerGLSL;
++        CompilerGLSL::Options Options;
+         Options.es      = IsES;
+         Options.version = GLSLVersion.Major * 100 + GLSLVersion.Minor * 10;
+ 
+@@ -441,15 +442,15 @@ private:
+         // For opcodes where we have to perform explicit additional nan checks, very ugly code is generated.
+         Options.relax_nan_checks = true;
+ 
+-        Options.fragment.default_float_precision = diligent_spirv_cross::CompilerGLSL::Options::Precision::DontCare;
+-        Options.fragment.default_int_precision   = diligent_spirv_cross::CompilerGLSL::Options::Precision::DontCare;
++        Options.fragment.default_float_precision = CompilerGLSL::Options::Precision::DontCare;
++        Options.fragment.default_int_precision   = CompilerGLSL::Options::Precision::DontCare;
+ 
+ #    if PLATFORM_APPLE
+         // Apple does not support GL_ARB_shading_language_420pack extension
+         Options.enable_420pack_extension = false;
+ #    endif
+ 
+-        diligent_spirv_cross::CompilerGLSL Compiler{std::move(SPIRV)};
++        CompilerGLSL Compiler{std::move(SPIRV)};
+         Compiler.set_common_options(Options);
+ 
+         OptimizedGLSL = Compiler.compile();
+diff --git a/Graphics/ShaderTools/src/SPIRVUtils.cpp b/Graphics/ShaderTools/src/SPIRVUtils.cpp
+index 8265ad9..c6a669d 100644
+--- a/Graphics/ShaderTools/src/SPIRVUtils.cpp
++++ b/Graphics/ShaderTools/src/SPIRVUtils.cpp
+@@ -25,6 +25,7 @@
+  */
+ 
+ #include "SPIRVUtils.hpp"
++#include "SPIRVShaderResources.hpp" // required for diligent_spirv_cross
+ 
+ #include "spirv_cross.hpp"
+ 

packages/d/diligentcore/xmake.lua

@@ -0,0 +1,195 @@
+package("diligentcore")
+    set_homepage("http://diligentgraphics.com/diligent-engine/")
+    set_description("A modern cross-platform low-level graphics API")
+    set_license("Apache-2.0")
+
+    add_urls("https://github.com/DiligentGraphics/DiligentCore/archive/refs/tags/$(version).tar.gz",
+             "https://github.com/DiligentGraphics/DiligentCore.git", {submodules = false})
+
+    add_versions("v2.5.6", "abc190c05ee7e5ef2bba52fcbc5fdfe2256cce3435efba9cfe263a386653f671")
+
+    add_patches("v2.5.6", "patches/v2.5.6/debundle-thirdparty.diff", "3d276a78e9ae47516668229dcb644f328a3602d389a3d73784eeb52d8a53108d")
+    add_patches("v2.5.6", "patches/v2.5.6/enforce-static-lib-type-for-platform-libraries.diff", "ee88a2a04348dcc9de7960a87ff5dc1fb1b534caf1f6224bb2d0c88d37a4bc53")
+    add_patches("v2.5.6", "patches/v2.5.6/fix-build-deps-pkgconf.diff", "9998204546cf551a48301e972b582eeeaf002607a4f474086d7d80f4762451ee")
+    add_patches("v2.5.6", "patches/v2.5.6/fix-install-path.diff", "0fa50da9946dff8e57713edc4a224b8b54c548242e1c556d3dc11354eb69b2c1")
+    add_patches("v2.5.6", "patches/v2.5.6/fix-spirv-cross-namespace.diff", "d5a866d4b5bce061a3597dcc026cb88c4b9f92af352ef4071750d355b8b924f0")
+
+    add_includedirs("include", "include/DiligentCore")
+
+    add_deps("pkgconf")
+
+    if is_plat("windows", "linux", "mingw", "macosx") then
+        add_configs("opengl",           {description = "Enable OpenGL/GLES backend", default = true, type = "boolean"})
+    end
+
+    if is_plat("windows") then
+        add_configs("d3d11",            {description = "Enable Direct3D11 backend", default = true, type = "boolean"})
+        add_configs("d3d12",            {description = "Enable Direct3D12 backend", default = true, type = "boolean"})
+    end
+
+    add_configs("vulkan",               {description = "Enable Vulkan backend", default = true, type = "boolean"})
+
+    add_configs("hlsl",                 {description = "Enable HLSL", default = true, type = "boolean"})
+    add_configs("glslang",              {description = "Enable GLSLang", default = true, type = "boolean"})
+    add_configs("archiver",             {description = "Enable archiver", default = true, type = "boolean"})
+    add_configs("format_validation",    {description = "Enable format validation", default = false, type = "boolean"})
+
+    if is_plat("linux") then
+        add_syslinks("pthread", "dl")
+    end
+
+    if is_plat("macosx") then
+        add_frameworks("AppKit")
+    elseif is_plat("iphoneos") then
+        add_frameworks("CoreFoundation", "Foundation", "OpenGLES")
+    end
+
+    add_deps("cmake")
+    add_deps("xxhash")
+
+    if is_plat("linux") then
+        add_deps("libx11", "libxrandr", "libxrender", "libxinerama", "libxfixes", "libxcursor", "libxi", "libxext", "wayland")
+    end
+
+    on_load(function (package)
+        if package:is_plat("windows") then
+            package:add("defines", "NOMINMAX", "WIN32_LEAN_AND_MEAN", "UNICODE")
+        end
+        if package:config("shared") then
+            package:add("defines", "ENGINE_DLL=1")
+        end
+
+        if package:config("opengl") then
+            package:add("deps", "opengl", "glew")
+            if package:is_plat("macosx") then
+                package:add("frameworks", "OpenGL")
+            end
+        end
+
+        if package:config("vulkan") then
+            package:add("deps", "vulkan-headers")
+            package:add("deps", "volk", {configs = {header_only = true}})
+        end
+
+        if package:config("vulkan") or (package:config("archiver") and package:config("opengl")) then
+            package:add("deps", "spirv-headers")
+        end
+
+        if package:config("hlsl") or package:config("archiver") or package:config("glslang") then
+            if package:is_plat("linux") then
+                package:add("deps", "glslang", {configs = {shared = true}})
+            else
+                package:add("deps", "glslang")
+            end
+            package:add("deps", "spirv-tools")
+        end
+
+        package:add("deps", "spirv-cross")
+    end)
+
+    on_install("windows", "linux", "macosx", function (package)
+        -- Dump CMakeLists.txt variables related for platform & rendering backend for package defines
+        local CMakeLists_content = io.readfile("CMakeLists.txt")
+        io.writefile("CMakeLists.txt", CMakeLists_content .. [[
+get_cmake_property(vars VARIABLES)
+list(SORT vars)
+set(TARGET_VARS
+    PLATFORM_ANDROID PLATFORM_EMSCRIPTEN PLATFORM_IOS PLATFORM_LINUX PLATFORM_MACOS PLATFORM_TVOS PLATFORM_UNIVERSAL_WINDOWS PLATFORM_WIN32
+    ARCHIVER_SUPPORTED D3D11_SUPPORTED D3D12_SUPPORTED GLES_SUPPORTED GL_SUPPORTED METAL_SUPPORTED VULKAN_SUPPORTED WEBGPU_SUPPORTED
+)
+file(WRITE "${CMAKE_BINARY_DIR}/variables.txt" "")
+foreach(var IN LISTS vars)
+    if(var IN_LIST TARGET_VARS)
+        file(APPEND "${CMAKE_BINARY_DIR}/variables.txt" "${var}=${${var}}\n")
+    endif()
+endforeach()
+]])
+
+        local configs = {"-DDILIGENT_INSTALL_CORE=ON"}
+
+        table.insert(configs, "-DBUILD_SHARED_LIBS=" .. (package:config("shared") and "ON" or "OFF"))
+        table.insert(configs, "-DCMAKE_BUILD_TYPE=" .. (package:is_debug() and "Debug" or "Release"))
+
+        table.insert(configs, "-DDILIGENT_INSTALL_PDB=" .. (package:is_debug() and "ON" or "OFF"))
+        table.insert(configs, "-DDILIGENT_DEVELOPMENT=" .. (package:is_debug() and "ON" or "OFF"))
+
+        table.insert(configs, "-DDILIGENT_NO_OPENGL=" .. (package:config("opengl") and "OFF" or "ON"))
+
+        table.insert(configs, "-DDILIGENT_NO_DIRECT3D11=" .. (package:config("d3d11") and "OFF" or "ON"))
+        table.insert(configs, "-DDILIGENT_NO_DIRECT3D12=" .. (package:config("d3d12") and "OFF" or "ON"))
+
+        table.insert(configs, "-DDILIGENT_NO_VULKAN=" .. (package:config("vulkan") and "OFF" or "ON"))
+
+        table.insert(configs, "-DDILIGENT_NO_ARCHIVER=" .. (package:config("archiver") and "OFF" or "ON"))
+        table.insert(configs, "-DDILIGENT_NO_HLSL=" .. (package:config("hlsl") and "OFF" or "ON"))
+        table.insert(configs, "-DDILIGENT_NO_GLSLANG=" .. (package:config("glslang") and "OFF" or "ON"))
+        table.insert(configs, "-DDILIGENT_NO_FORMAT_VALIDATION=" .. (package:config("format_validation") and "OFF" or "ON"))
+
+        import("package.tools.cmake").install(package, configs)
+        -- Gather missing defines into *data* so we could gather *data* for on_test
+        local vars_file = path.join(package:buildir(), "variables.txt")
+        if os.isfile(vars_file) then
+            local content = io.readfile(vars_file)
+            for _, line in ipairs(content:split("\n")) do
+                line = line:trim()
+                if #line > 0 then
+                    local var, value = line:match("^([^=]+)=(.+)$")
+                    if var and value == "TRUE" then
+                        package:add("defines", var)
+                    end
+                end
+            end
+        end
+        -- Move every folder of $(builddir)/include into prepended folder include/DiligentCore
+        local target_dir = path.join(package:installdir("include"), "DiligentCore")
+        os.mkdir(target_dir)
+        for _, dir in ipairs(os.dirs(package:installdir("include/*"))) do
+            if dir ~= target_dir then
+                os.mv(dir, target_dir)
+            end
+        end
+    end)
+
+    on_test(function (package)
+        if package:config("opengl") then
+            assert(package:check_cxxsnippets({test = [[
+                #include <DiligentCore/Graphics/GraphicsEngineOpenGL/interface/EngineFactoryOpenGL.h>
+                void test() {
+                    Diligent::EngineGLCreateInfo create_info;
+                    Diligent::IEngineFactoryOpenGL* factory = nullptr;
+                    Diligent::SwapChainDesc scd;
+                    factory->CreateDeviceAndSwapChainGL(create_info, nullptr, nullptr, scd, nullptr);
+                }
+            ]]}, {configs = {languages = "c++17"}}))
+        end
+        if package:config("d3d11") then
+            assert(package:check_cxxsnippets({test = [[
+                #include <DiligentCore/Graphics/GraphicsEngineD3D11/interface/EngineFactoryD3D11.h>
+                void test() {
+                    Diligent::EngineD3D11CreateInfo create_info;
+                    Diligent::IEngineFactoryD3D11* factory = nullptr;
+                    factory->CreateDeviceAndContextsD3D11(create_info, nullptr, nullptr);
+                }
+            ]]}, {configs = {languages = "c++17"}}))
+        end
+        if package:config("d3d12") then
+            assert(package:check_cxxsnippets({test = [[
+                #include <DiligentCore/Graphics/GraphicsEngineD3D12/interface/EngineFactoryD3D12.h>
+                void test() {
+                    Diligent::EngineD3D12CreateInfo create_info;
+                    Diligent::IEngineFactoryD3D12* factory = nullptr;
+                    factory->CreateDeviceAndContextsD3D12(create_info, nullptr, nullptr);
+                }
+            ]]}, {configs = {languages = "c++17"}}))
+        end
+        if package:config("vulkan") then
+            assert(package:check_cxxsnippets({test = [[
+                #include <DiligentCore/Graphics/GraphicsEngineVulkan/interface/EngineFactoryVk.h>
+                void test() {
+                    Diligent::EngineVkCreateInfo create_info;
+                    Diligent::IEngineFactoryVk* factory = nullptr;
+                    factory->CreateDeviceAndContextsVk(create_info, nullptr, nullptr);
+                }
+            ]]}, {configs = {languages = "c++17"}}))
+        end
+    end)