diff --git a/native/build/libcocos2d.vcxproj b/native/build/libcocos2d.vcxproj
index 26a77f7208..a65d83a7e6 100644
--- a/native/build/libcocos2d.vcxproj
+++ b/native/build/libcocos2d.vcxproj
@@ -53,24 +53,31 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -248,26 +255,36 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -509,12 +526,12 @@
$(EngineRoot)external\win32\libs;$(MSBuildProgramFiles32)\Microsoft SDKs\Windows\v7.1A\lib;$(LibraryPath)
$(ProjectName)
- $(ProjectDir)..\cocos\renderer;$(ProjectDir)..\cocos\renderer\core;$(ProjectDir)..\external\sources\tommyds;$(ProjectDir)..\external\sources\khronos;$(ProjectDir)..\external\sources\jemalloc\include-win;$(ProjectDir)..\external\sources\jemalloc\include-win\msvc_compat;$(IncludePath)
+ $(ProjectDir)..\cocos\renderer;$(ProjectDir)..\cocos\renderer\core;$(ProjectDir)..\external\sources\tommyds;$(ProjectDir)..\external\sources\khronos;$(ProjectDir)..\external\sources\jemalloc\include-win;$(ProjectDir)..\external\sources\jemalloc\include-win\msvc_compat;$(ProjectDir)..\external\sources\glslang;$(IncludePath)
$(EngineRoot)external\win32\libs;$(MSBuildProgramFiles32)\Microsoft SDKs\Windows\v7.1A\lib;$(LibraryPath)
$(ProjectName)
- $(ProjectDir)..\cocos\renderer\core;$(ProjectDir)..\external\sources\tommyds;$(ProjectDir)..\external\sources\khronos;$(ProjectDir)..\external\sources\jemalloc\include-win;$(ProjectDir)..\external\sources\jemalloc\include-win\msvc_compat;$(IncludePath)
+ $(ProjectDir)..\cocos\renderer;$(ProjectDir)..\cocos\renderer\core;$(ProjectDir)..\external\sources\tommyds;$(ProjectDir)..\external\sources\khronos;$(ProjectDir)..\external\sources\jemalloc\include-win;$(ProjectDir)..\external\sources\jemalloc\include-win\msvc_compat;$(ProjectDir)..\external\sources\glslang;$(IncludePath)
@@ -524,7 +541,7 @@
Disabled
$(ProjectDir)..\cocos;$(ProjectDir)..\external\sources;$(ProjectDir)..\cocos\renderer\gfx;$(ProjectDir)..\cocos\renderer;$(ProjectDir)..\cocos\platform;$(ProjectDir)..\external\win32\include\zlib;$(ProjectDir)..\external\win32\include\v8;$(ProjectDir)..\external\sources\firefox;$(projectDir)..;$(ProjectDir)..\external\win32\include;$(ProjectDir)..\external\win32\include\uv;$(ProjectDir)..\cocos\editor-support
- WIN32;CC_STATIC;_USRDLL;_LIB;COCOS2D_DEBUG=1;JS_HAVE____INTN;JS_INTPTR_TYPE=int;XP_WIN;_CRT_SECURE_NO_WARNINGS;_WINDOWS;_WIN32;__MWERKS__;CC_CORE_EXPORTS;GLEW_BUILD;%(PreprocessorDefinitions)
+ WIN32;CC_STATIC;_USRDLL;_LIB;COCOS2D_DEBUG=1;JS_HAVE____INTN;JS_INTPTR_TYPE=int;XP_WIN;_CRT_SECURE_NO_WARNINGS;_WINDOWS;_WIN32;__MWERKS__;CC_CORE_EXPORTS;GLEW_BUILD;VK_USE_PLATFORM_WIN32_KHR;%(PreprocessorDefinitions)
false
EnableFastChecks
MultiThreadedDebugDLL
@@ -565,7 +582,7 @@ xcopy /Y /Q "$(ProjectDir)..\external\win32\libs\Debug\*.*" "$(OutDir)"
- $(ProjectDir)..\cocos;$(ProjectDir)..\external\sources;$(ProjectDir)..\cocos\renderer\gfx;$(ProjectDir)..\cocos\renderer;$(ProjectDir)..\cocos\platform;$(ProjectDir)..\external\win32\include\zlib;$(ProjectDir)..\external\win32\include\v8;$(ProjectDir)..\external\sources\firefox;$(projectDir)..;$(ProjectDir)..\external\win32\include;$(ProjectDir)..\external\win32\include\uv;$(ProjectDir)..\cocos\editor-support
+ $(ProjectDir)..\cocos;$(ProjectDir)..\external\sources;$(ProjectDir)..\cocos\renderer\gfx;$(ProjectDir)..\cocos\renderer;$(ProjectDir)..\cocos\platform;$(ProjectDir)..\external\win32\include\zlib;$(ProjectDir)..\external\win32\include\v8;$(ProjectDir)..\external\sources\firefox;$(projectDir)..;$(ProjectDir)..\external\win32\include;$(ProjectDir)..\external\win32\include\uv;$(ProjectDir)..\cocos\editor-support;$(ProjectDir)..\external\sources\glslang
NDEBUG;WIN32;_WINDOWS;CC_STATIC;_USRDLL;USING_V8_SHARED;_LIB;JS_HAVE____INTN;JS_INTPTR_TYPE=int;XP_WIN;_CRT_SECURE_NO_WARNINGS;GLFW_EXPOSE_NATIVE_WIN32;GLFW_EXPOSE_NATIVE_WGL;_WIN32;__MWERKS__;CC_CORE_EXPORTS;%(PreprocessorDefinitions)
MultiThreadedDLL
diff --git a/native/build/libcocos2d.vcxproj.filters b/native/build/libcocos2d.vcxproj.filters
index a141d723a8..59dc7c0419 100644
--- a/native/build/libcocos2d.vcxproj.filters
+++ b/native/build/libcocos2d.vcxproj.filters
@@ -380,45 +380,6 @@
external\tommy
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
js-bindings\auto
@@ -560,6 +521,66 @@
js-bindings\auto
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
@@ -1070,51 +1091,6 @@
external\tommy
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
-
- external\tommy
-
js-bindings\auto
@@ -1271,6 +1247,81 @@
js-bindings\auto
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
+
+ renderer\gfx-vulkan
+
@@ -1384,6 +1435,9 @@
{6cd7b083-875a-4f76-8de5-e7c3f7baba1d}
+
+ {58b6724a-9662-42af-afa5-e49c7b9ade5b}
+
diff --git a/native/cocos/renderer/CMakeLists.txt b/native/cocos/renderer/CMakeLists.txt
index 0ecb28e58a..567d6144f5 100644
--- a/native/cocos/renderer/CMakeLists.txt
+++ b/native/cocos/renderer/CMakeLists.txt
@@ -1,7 +1,9 @@
add_subdirectory(core)
if(COCOS_PLATFORM_WIN32)
+ add_subdirectory(gfx-gles2)
add_subdirectory(gfx-gles3)
+ add_subdirectory(gfx-vulkan)
elseif(COCOS_PLATFORM_IOS)
add_subdirectory(gfx-gles3)
add_subdirectory(gfx-metal)
diff --git a/native/cocos/renderer/core/CoreDef.h b/native/cocos/renderer/core/CoreDef.h
index 352838040b..108da80821 100755
--- a/native/cocos/renderer/core/CoreDef.h
+++ b/native/cocos/renderer/core/CoreDef.h
@@ -306,15 +306,15 @@ Note:
#define CC_TOSTR(s) #s
#if (CC_PLATFORM == CC_PLATFORM_WINDOWS)
-# ifdef CC_STATIC
-# define CC_CORE_API
-# else
+//# ifdef CC_STATIC
+//# define CC_CORE_API
+//# else
# ifdef CC_CORE_EXPORTS
# define CC_CORE_API __declspec(dllexport)
# else
# define CC_CORE_API __declspec(dllimport)
# endif
-# endif
+//# endif
#else
# define CC_CORE_API
#endif
diff --git a/native/cocos/renderer/core/gfx/GFXCommandBuffer.h b/native/cocos/renderer/core/gfx/GFXCommandBuffer.h
index 3f956ce9ec..608d2c7e1f 100755
--- a/native/cocos/renderer/core/gfx/GFXCommandBuffer.h
+++ b/native/cocos/renderer/core/gfx/GFXCommandBuffer.h
@@ -44,9 +44,9 @@ protected:
GFXDevice* _device = nullptr;
GFXCommandAllocator* _allocator = nullptr;
GFXCommandBufferType _type = GFXCommandBufferType::PRIMARY;
- uint _numDrawCalls = 0;
- uint _numInstances = 0;
- uint _numTriangles = 0;
+ uint32_t _numDrawCalls = 0;
+ uint32_t _numInstances = 0;
+ uint32_t _numTriangles = 0;
};
NS_CC_END
diff --git a/native/cocos/renderer/core/gfx/GFXCommandPool.h b/native/cocos/renderer/core/gfx/GFXCommandPool.h
index 526c8cd578..0051a36d39 100644
--- a/native/cocos/renderer/core/gfx/GFXCommandPool.h
+++ b/native/cocos/renderer/core/gfx/GFXCommandPool.h
@@ -4,13 +4,15 @@
NS_CC_BEGIN
+#define INITIAL_CAPACITY 1
+
template ::value>>
class GFXCommandPool {
public:
- GFXCommandPool(): _freeCmds(1) {
- _frees = new T*[1];
- _count = 1;
- _freeIdx = 0;
+ GFXCommandPool(): _freeCmds(INITIAL_CAPACITY) {
+ _frees = new T*[INITIAL_CAPACITY];
+ _count = INITIAL_CAPACITY;
+ _freeIdx = INITIAL_CAPACITY - 1;
for (uint i = 0; i < _count; ++i) {
_frees[i] = CC_NEW(T);
}
diff --git a/native/cocos/renderer/core/gfx/GFXDef.h b/native/cocos/renderer/core/gfx/GFXDef.h
index a6152f5091..42cb800df8 100755
--- a/native/cocos/renderer/core/gfx/GFXDef.h
+++ b/native/cocos/renderer/core/gfx/GFXDef.h
@@ -545,7 +545,7 @@ enum class GFXVsyncMode : uint8_t {
RELAXED,
// The presentation engine will always use the latest fully rendered image. Compared to OFF, no tearing will be observed. Compared to ON, battery power will be worse, especially for faster applications. If unsupported, "OFF" will be attempted next.
MAILBOX,
- // The application is capped to using half the vertical sync time. FPS artificially capped to Half the display speed (usually 30fps) to maintain battery. Best possible battery savings. Worst possibly performance. Recommended for specific applications where battery saving is critical.
+ // The application is capped to using half the vertical sync time. FPS artificially capped to Half the display speed (usually 30fps) to maintain battery. Best possible battery savings. Worst possible performance. Recommended for specific applications where battery saving is critical.
HALF,
};
@@ -621,7 +621,7 @@ struct GFXViewport {
uint width = 0;
uint height = 0;
float minDepth = 0.0f;
- float maxDepth = 0.0f;
+ float maxDepth = 1.0f;
bool operator ==(const GFXViewport& rs)
{
@@ -679,7 +679,7 @@ struct GFXWindowInfo {
struct GFXContextInfo {
uintptr_t windowHandle = 0;
GFXContext* sharedCtx = nullptr;
- GFXVsyncMode vsyncMode = GFXVsyncMode::OFF;
+ GFXVsyncMode vsyncMode = GFXVsyncMode::RELAXED;
};
struct GFXBufferInfo {
diff --git a/native/cocos/renderer/core/gfx/GFXDevice.h b/native/cocos/renderer/core/gfx/GFXDevice.h
index a023fd4816..b74128c0fb 100755
--- a/native/cocos/renderer/core/gfx/GFXDevice.h
+++ b/native/cocos/renderer/core/gfx/GFXDevice.h
@@ -14,6 +14,7 @@ class CC_CORE_API GFXDevice : public Object {
virtual bool initialize(const GFXDeviceInfo& info) = 0;
virtual void destroy() = 0;
virtual void resize(uint width, uint height) = 0;
+ virtual void begin() = 0;
virtual void present() = 0;
virtual GFXWindow* createWindow(const GFXWindowInfo& info) = 0;
virtual GFXQueue* createQueue(const GFXQueueInfo& info) = 0;
diff --git a/native/cocos/renderer/gfx-gles2/GLES2Device.h b/native/cocos/renderer/gfx-gles2/GLES2Device.h
index 89d1092b5f..614476dd5a 100644
--- a/native/cocos/renderer/gfx-gles2/GLES2Device.h
+++ b/native/cocos/renderer/gfx-gles2/GLES2Device.h
@@ -16,6 +16,7 @@ public:
bool initialize(const GFXDeviceInfo& info) override;
void destroy() override;
void resize(uint width, uint height) override;
+ void begin() override {};
void present() override;
GFXWindow* createWindow(const GFXWindowInfo& info) override;
GFXQueue* createQueue(const GFXQueueInfo& info) override;
diff --git a/native/cocos/renderer/gfx-gles2/GLES2Std.cc b/native/cocos/renderer/gfx-gles2/GLES2Std.cc
index 2b22798869..93548c1fc0 100644
--- a/native/cocos/renderer/gfx-gles2/GLES2Std.cc
+++ b/native/cocos/renderer/gfx-gles2/GLES2Std.cc
@@ -1 +1 @@
-#include "GLES2Std.h"
\ No newline at end of file
+#include "GLES2Std.h"
diff --git a/native/cocos/renderer/gfx-gles3/GLES3Device.h b/native/cocos/renderer/gfx-gles3/GLES3Device.h
index 75dccb6df5..e1378dc82c 100644
--- a/native/cocos/renderer/gfx-gles3/GLES3Device.h
+++ b/native/cocos/renderer/gfx-gles3/GLES3Device.h
@@ -16,6 +16,7 @@ public:
bool initialize(const GFXDeviceInfo& info) override;
void destroy() override;
void resize(uint width, uint height) override;
+ void begin() override {};
void present() override;
GFXWindow* createWindow(const GFXWindowInfo& info) override;
GFXQueue* createQueue(const GFXQueueInfo& info) override;
diff --git a/native/cocos/renderer/gfx-gles3/GLES3Queue.cc b/native/cocos/renderer/gfx-gles3/GLES3Queue.cc
index 9652fd6e16..5e406ff1a8 100644
--- a/native/cocos/renderer/gfx-gles3/GLES3Queue.cc
+++ b/native/cocos/renderer/gfx-gles3/GLES3Queue.cc
@@ -14,13 +14,13 @@ GLES3Queue::~GLES3Queue() {
bool GLES3Queue::initialize(const GFXQueueInfo &info) {
_type = info.type;
- _status = GFXStatus::SUCCESS;
+ _status = GFXStatus::SUCCESS;
return true;
}
void GLES3Queue::destroy() {
- _status = GFXStatus::UNREADY;
+ _status = GFXStatus::UNREADY;
}
void GLES3Queue::submit(const std::vector& cmd_buffs) {
diff --git a/native/cocos/renderer/gfx-gles3/GLES3Std.cc b/native/cocos/renderer/gfx-gles3/GLES3Std.cc
index 1daef89c30..2329f8557c 100644
--- a/native/cocos/renderer/gfx-gles3/GLES3Std.cc
+++ b/native/cocos/renderer/gfx-gles3/GLES3Std.cc
@@ -1 +1 @@
-#include "GLES3Std.h"
\ No newline at end of file
+#include "GLES3Std.h"
diff --git a/native/cocos/renderer/gfx-vulkan/CMakeLists.txt b/native/cocos/renderer/gfx-vulkan/CMakeLists.txt
new file mode 100644
index 0000000000..c38cbde2da
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/CMakeLists.txt
@@ -0,0 +1,87 @@
+set(TARGET_NAME GFXVulkan)
+
+message(STATUS "Target: ${TARGET_NAME}...")
+# ---------------------------------------------------------------------
+# set include files
+
+set(INCLUDE_FILES
+ ${GFX_EXTERNAL_PATH}/khronos
+ ${GFX_EXTERNAL_PATH}/glslang
+ ${COCOS_SRC_PATH}/renderer/core
+ ${COCOS_SRC_PATH}/renderer/gfx-vulkan
+)
+
+add_subdirectory(${GFX_EXTERNAL_PATH}/glslang glslang)
+
+if(WIN32)
+ add_definitions("-DVK_USE_PLATFORM_WIN32_KHR")
+ add_definitions("-DNOMINMAX")
+elseif(COCOS_PLATFORM_IOS)
+ add_definitions("-DVK_USE_PLATFORM_IOS_MVK")
+elseif(COCOS_PLATFORM_OSX)
+ add_definitions("-DVK_USE_PLATFORM_MACOS_MVK")
+else()
+ add_definitions("-DVK_USE_PLATFORM_XLIB_KHR")
+endif()
+
+if(WIN32)
+ list(APPEND INCLUDE_FILES ${GFX_EXTERNAL_PATH}/pvrsdk/include)
+
+if(COCOS_CPU_X64)
+ set(PVRSDK_LIB_DIR ${GFX_EXTERNAL_PATH}/pvrsdk/lib/Windows_x86_64)
+else()
+ set(PVRSDK_LIB_DIR ${GFX_EXTERNAL_PATH}/pvrsdk/lib/Windows_x86_32)
+endif()
+
+ link_libraries(
+ ${PVRSDK_LIB_DIR}/libEGL.lib
+ ${PVRSDK_LIB_DIR}/libGLESv2.lib
+ )
+endif()
+
+include_directories( ${INCLUDE_FILES} )
+
+# ---------------------------------------------------------------------
+
+file(GLOB_RECURSE HEADER_FILES *.h)
+file(GLOB_RECURSE SOURCE_CPP_FILES *.cpp *.cc)
+file(GLOB_RECURSE SOURCE_C_FILES *.c)
+
+if(COCOS_PLATFORM_IOS OR COCOS_PLATFORM_OSX)
+ file(GLOB_RECURSE SOURCE_MM_FILES *.m *.mm)
+endif()
+
+set(ALL_FILES ${HEADER_FILES} ${SOURCE_CPP_FILES} ${SOURCE_C_FILES})
+
+if(COCOS_PLATFORM_IOS OR COCOS_PLATFORM_OSX)
+ set(ALL_FILES ${ALL_FILES} ${SOURCE_MM_FILES})
+endif()
+
+if(COCOS_PLATFORM_IOS OR COCOS_PLATFORM_OSX)
+ list(REMOVE_ITEM ALL_FILES "${COCOS_SRC_PATH}/renderer/gfx-vulkan/gles3w.c")
+else()
+ list(REMOVE_ITEM ALL_FILES "${COCOS_SRC_PATH}/renderer/gfx-vulkan/gles3w.mm")
+endif()
+
+add_definitions("-DCC_VK_EXPORTS")
+if(WIN32)
+ add_definitions("-DGLEW_BUILD")
+endif()
+if(COCOS_UNICODE)
+ add_definitions("-DUNICODE -D_UNICODE")
+endif()
+
+if (COCOS_STATIC)
+ add_library(${TARGET_NAME} STATIC ${HEADER_FILES} ${ALL_FILES})
+else()
+ add_library(${TARGET_NAME} SHARED ${HEADER_FILES} ${ALL_FILES})
+endif()
+
+target_link_libraries(${TARGET_NAME} Core glslang SPIRV)
+
+set_target_properties(${TARGET_NAME} PROPERTIES OUTPUT_NAME CCGFXVulkan)
+set_target_properties(${TARGET_NAME} PROPERTIES OUTPUT_NAME_DEBUG CCGFXVulkan_d)
+
+use_precompiled_header("${CMAKE_CURRENT_SOURCE_DIR}/VKStd.h" "${CMAKE_CURRENT_SOURCE_DIR}/VKStd.cpp" SOURCE_CPP_FILES)
+
+message(STATUS "${TARGET_NAME} configuration completed.")
diff --git a/native/cocos/renderer/gfx-vulkan/GFXVulkan.h b/native/cocos/renderer/gfx-vulkan/GFXVulkan.h
new file mode 100644
index 0000000000..56db6c2707
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/GFXVulkan.h
@@ -0,0 +1,7 @@
+#ifndef CC_GFXVULKAN_VK_H_
+#define CC_GFXVULKAN_VK_H_
+
+#include "VKStd.h"
+#include "VKDevice.h"
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc
new file mode 100644
index 0000000000..3d91bc4b9b
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc
@@ -0,0 +1,100 @@
+#include "VKStd.h"
+#include "VKBindingLayout.h"
+#include "VKCommands.h"
+#include "VKBuffer.h"
+#include "VKTextureView.h"
+#include "VKSampler.h"
+
+NS_CC_BEGIN
+
+CCVKBindingLayout::CCVKBindingLayout(GFXDevice* device)
+ : GFXBindingLayout(device)
+{
+}
+
+CCVKBindingLayout::~CCVKBindingLayout()
+{
+}
+
+bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info)
+{
+ if (info.bindings.size())
+ {
+ _bindingUnits.resize(info.bindings.size());
+ for (size_t i = 0; i < _bindingUnits.size(); ++i)
+ {
+ GFXBindingUnit& bindingUnit = _bindingUnits[i];
+ const GFXBinding& binding = info.bindings[i];
+ bindingUnit.binding = binding.binding;
+ bindingUnit.type = binding.type;
+ bindingUnit.name = binding.name;
+ }
+ }
+
+ _gpuBindingLayout = CC_NEW(CCVKGPUBindingLayout);
+ _gpuBindingLayout->gpuBindings.resize(_bindingUnits.size());
+ for (size_t i = 0; i < _gpuBindingLayout->gpuBindings.size(); ++i)
+ {
+ CCVKGPUBinding& gpuBinding = _gpuBindingLayout->gpuBindings[i];
+ const GFXBindingUnit& bindingUnit = _bindingUnits[i];
+ gpuBinding.binding = bindingUnit.binding;
+ gpuBinding.type = bindingUnit.type;
+ gpuBinding.name = bindingUnit.name;
+ }
+
+ CCVKCmdFuncCreateBindingLayout((CCVKDevice*)_device, _gpuBindingLayout);
+
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKBindingLayout::destroy()
+{
+ if (_gpuBindingLayout)
+ {
+ CCVKCmdFuncDestroyBindingLayout((CCVKDevice*)_device, _gpuBindingLayout);
+ CC_DELETE(_gpuBindingLayout);
+ _gpuBindingLayout = nullptr;
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+void CCVKBindingLayout::update()
+{
+ if (_isDirty && _gpuBindingLayout)
+ {
+ for (size_t i = 0; i < _bindingUnits.size(); ++i)
+ {
+ GFXBindingUnit& bindingUnit = _bindingUnits[i];
+ switch (bindingUnit.type)
+ {
+ case GFXBindingType::UNIFORM_BUFFER:
+ {
+ if (bindingUnit.buffer)
+ {
+ _gpuBindingLayout->gpuBindings[i].gpuBuffer = ((CCVKBuffer*)bindingUnit.buffer)->gpuBuffer();
+ }
+ break;
+ }
+ case GFXBindingType::SAMPLER:
+ {
+ if (bindingUnit.texView)
+ {
+ _gpuBindingLayout->gpuBindings[i].gpuTexView = ((CCVKTextureView*)bindingUnit.texView)->gpuTexView();
+ }
+ if (bindingUnit.sampler)
+ {
+ _gpuBindingLayout->gpuBindings[i].gpuSampler = ((CCVKSampler*)bindingUnit.sampler)->gpuSampler();
+ }
+ break;
+ }
+ default:;
+ }
+ }
+ _isDirty = false;
+ }
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h
new file mode 100644
index 0000000000..ffe7b9f34f
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h
@@ -0,0 +1,27 @@
+#ifndef CC_GFXVULKAN_CCVK_BINDING_LAYOUT_H_
+#define CC_GFXVULKAN_CCVK_BINDING_LAYOUT_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUBindingLayout;
+
+class CC_VULKAN_API CCVKBindingLayout : public GFXBindingLayout
+{
+public:
+ CCVKBindingLayout(GFXDevice* device);
+ ~CCVKBindingLayout();
+
+public:
+ bool initialize(const GFXBindingLayoutInfo& info);
+ void destroy();
+ void update();
+
+ CC_INLINE CCVKGPUBindingLayout* gpuBindingLayout() const { return _gpuBindingLayout; }
+
+private:
+ CCVKGPUBindingLayout* _gpuBindingLayout = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKBuffer.cc b/native/cocos/renderer/gfx-vulkan/VKBuffer.cc
new file mode 100644
index 0000000000..9c2193ff57
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKBuffer.cc
@@ -0,0 +1,106 @@
+#include "VKStd.h"
+#include "VKBuffer.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKBuffer::CCVKBuffer(GFXDevice* device)
+ : GFXBuffer(device)
+{
+}
+
+CCVKBuffer::~CCVKBuffer()
+{
+}
+
+bool CCVKBuffer::initialize(const GFXBufferInfo& info)
+{
+ _usage = info.usage;
+ _memUsage = info.memUsage;
+ _size = info.size;
+ _stride = std::max(info.stride, 1u);
+ _count = _size / _stride;
+ _flags = info.flags;
+
+ if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0)
+ {
+ _buffer = (uint8_t*)CC_MALLOC(_size);
+ _device->getMemoryStatus().bufferSize += _size;
+ }
+
+ _gpuBuffer = CC_NEW(CCVKGPUBuffer);
+ _gpuBuffer->usage = _usage;
+ _gpuBuffer->memUsage = _memUsage;
+ _gpuBuffer->size = _size;
+ _gpuBuffer->stride = _stride;
+ _gpuBuffer->count = _count;
+
+ //if (!(_usage & GFXBufferUsageBit::INDIRECT))
+ //{
+ // _gpuBuffer->buffer = _buffer;
+ //}
+
+ CCVKCmdFuncCreateBuffer((CCVKDevice*)_device, _gpuBuffer);
+ _device->getMemoryStatus().bufferSize += _size;
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKBuffer::destroy()
+{
+ if (_gpuBuffer)
+ {
+ CCVKCmdFuncDestroyBuffer((CCVKDevice*)_device, _gpuBuffer);
+ _device->getMemoryStatus().bufferSize -= _size;
+ CC_DELETE(_gpuBuffer);
+ _gpuBuffer = nullptr;
+ }
+
+ if (_buffer)
+ {
+ CC_FREE(_buffer);
+ _device->getMemoryStatus().bufferSize -= _size;
+ _buffer = nullptr;
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+void CCVKBuffer::resize(uint size)
+{
+ if (_size != size)
+ {
+ const uint old_size = _size;
+ _size = size;
+ _count = _size / _stride;
+
+ GFXMemoryStatus& status = _device->getMemoryStatus();
+ _gpuBuffer->size = _size;
+ _gpuBuffer->count = _count;
+ CCVKCmdFuncResizeBuffer((CCVKDevice*)_device, _gpuBuffer);
+ status.bufferSize -= old_size;
+ status.bufferSize += _size;
+
+ if (_buffer)
+ {
+ const uint8_t* old_buff = _buffer;
+ _buffer = (uint8_t*)CC_MALLOC(_size);
+ memcpy(_buffer, old_buff, old_size);
+ CC_FREE(_buffer);
+ status.bufferSize -= old_size;
+ status.bufferSize += _size;
+ }
+ }
+}
+
+void CCVKBuffer::update(void* buffer, uint offset, uint size)
+{
+ if (_buffer)
+ {
+ memcpy(_buffer + offset, buffer, size);
+ }
+ CCVKCmdFuncUpdateBuffer((CCVKDevice*)_device, _gpuBuffer, buffer, offset, size);
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKBuffer.h b/native/cocos/renderer/gfx-vulkan/VKBuffer.h
new file mode 100644
index 0000000000..61a9eb187a
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKBuffer.h
@@ -0,0 +1,28 @@
+#ifndef CC_GFXVULKAN_CCVK_BUFFER_H_
+#define CC_GFXVULKAN_CCVK_BUFFER_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUBuffer;
+
+class CC_VULKAN_API CCVKBuffer : public GFXBuffer
+{
+public:
+ CCVKBuffer(GFXDevice* device);
+ ~CCVKBuffer();
+
+public:
+ bool initialize(const GFXBufferInfo& info);
+ void destroy();
+ void resize(uint size);
+ void update(void* buffer, uint offset, uint size);
+
+ CC_INLINE CCVKGPUBuffer* gpuBuffer() const { return _gpuBuffer; }
+
+private:
+ CCVKGPUBuffer* _gpuBuffer = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc
new file mode 100644
index 0000000000..c8e9e56d50
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc
@@ -0,0 +1,33 @@
+#include "VKStd.h"
+#include "VKCommandAllocator.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKCommandAllocator::CCVKCommandAllocator(GFXDevice* device)
+ : GFXCommandAllocator(device)
+{
+}
+
+CCVKCommandAllocator::~CCVKCommandAllocator()
+{
+}
+
+bool CCVKCommandAllocator::initialize(const GFXCommandAllocatorInfo& info)
+{
+ _gpuCommandPool = CC_NEW(CCVKGPUCommandPool);
+
+ CCVKCmdFuncCreateCommandPool((CCVKDevice*)_device, _gpuCommandPool);
+
+ _status = GFXStatus::SUCCESS;
+ return true;
+}
+
+void CCVKCommandAllocator::destroy()
+{
+ CCVKCmdFuncDestroyCommandPool((CCVKDevice*)_device, _gpuCommandPool);
+
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h
new file mode 100644
index 0000000000..046612bb03
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h
@@ -0,0 +1,25 @@
+#ifndef CC_GFXVULKAN_CCVK_COMMAND_ALLOCATOR_H_
+#define CC_GFXVULKAN_CCVK_COMMAND_ALLOCATOR_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUCommandPool;
+
+class CC_VULKAN_API CCVKCommandAllocator : public GFXCommandAllocator {
+public:
+ CCVKCommandAllocator(GFXDevice* device);
+ ~CCVKCommandAllocator();
+
+public:
+ bool initialize(const GFXCommandAllocatorInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUCommandPool* gpuCommandPool() { return _gpuCommandPool; }
+
+private:
+ CCVKGPUCommandPool* _gpuCommandPool;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc
new file mode 100644
index 0000000000..33c60bfd35
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc
@@ -0,0 +1,361 @@
+#include "VKStd.h"
+#include "VKCommandBuffer.h"
+#include "VKCommands.h"
+#include "VKCommandAllocator.h"
+#include "VKFramebuffer.h"
+
+#include "VKPipelineState.h"
+#include "VKBindingLayout.h"
+#include "VKInputAssembler.h"
+
+NS_CC_BEGIN
+
+CCVKCommandBuffer::CCVKCommandBuffer(GFXDevice* device)
+ : GFXCommandBuffer(device)
+{
+}
+
+CCVKCommandBuffer::~CCVKCommandBuffer()
+{
+}
+
+bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo& info)
+{
+ if (!info.allocator)
+ {
+ return false;
+ }
+
+ _allocator = info.allocator;
+ _type = info.type;
+
+ _gpuCommandBuffer = CC_NEW(CCVKGPUCommandBuffer);
+ _gpuCommandBuffer->type = _type;
+ _gpuCommandBuffer->commandPool = ((CCVKCommandAllocator*)_allocator)->gpuCommandPool();
+ CCVKCmdFuncAllocateCommandBuffer((CCVKDevice*)_device, _gpuCommandBuffer);
+
+ _status = GFXStatus::SUCCESS;
+ return true;
+}
+
+void CCVKCommandBuffer::destroy()
+{
+ if (_gpuCommandBuffer)
+ {
+ CCVKCmdFuncFreeCommandBuffer((CCVKDevice*)_device, _gpuCommandBuffer);
+ CC_DELETE(_gpuCommandBuffer);
+ _gpuCommandBuffer = nullptr;
+ }
+
+ _allocator = nullptr;
+ _status = GFXStatus::UNREADY;
+}
+
+void CCVKCommandBuffer::begin()
+{
+ _curGPUPipelineState = nullptr;
+ _curGPUBlendLayout = nullptr;
+ _curGPUInputAssember = nullptr;
+ _numDrawCalls = 0;
+ _numInstances = 0;
+ _numTriangles = 0;
+
+ VkCommandBufferBeginInfo beginInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
+ beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+
+ if (_type == GFXCommandBufferType::SECONDARY)
+ {
+ VkCommandBufferInheritanceInfo inheritance{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO };
+ // TODO
+ //beginInfo.pInheritanceInfo = &inheritance;
+ }
+
+ VK_CHECK(vkBeginCommandBuffer(_gpuCommandBuffer->vkCommandBuffer, &beginInfo));
+}
+
+void CCVKCommandBuffer::end()
+{
+ if (_isStateInvalid)
+ {
+ BindStates();
+ }
+ _curGPUFBO = nullptr;
+
+ VK_CHECK(vkEndCommandBuffer(_gpuCommandBuffer->vkCommandBuffer));
+}
+
+void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer* fbo, const GFXRect& renderArea,
+ GFXClearFlags clearFlags, const std::vector& colors, float depth, int stencil)
+{
+ _curGPUFBO = ((CCVKFramebuffer*)fbo)->gpuFBO();
+ auto &renderPass = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuRenderPass : _curGPUFBO->swapchain->renderPass;
+ auto &barriers = renderPass->beginBarriers;
+ auto &clearValues = renderPass->clearValues;
+ auto attachmentCount = barriers.size();
+
+ if (attachmentCount)
+ {
+ for (uint32_t i = 0u; i < attachmentCount - 1; i++)
+ {
+ barriers[i].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuColorViews[i]->gpuTexture->vkImage :
+ _curGPUFBO->swapchain->swapchainImages[_curGPUFBO->swapchain->curImageIndex];
+ clearValues[i].color = { colors[i].r, colors[i].g, colors[i].b, colors[i].a };
+ }
+ barriers[attachmentCount - 1].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuDepthStencilView->gpuTexture->vkImage :
+ _curGPUFBO->swapchain->depthStencilImages[_curGPUFBO->swapchain->curImageIndex];
+ clearValues[attachmentCount - 1].depthStencil = { depth, (uint32_t)stencil };
+
+ vkCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+ VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, barriers.size(), barriers.data());
+ }
+
+ VkRenderPassBeginInfo passBeginInfo{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
+ passBeginInfo.renderPass = _curGPUFBO->gpuRenderPass->vkRenderPass;
+ passBeginInfo.framebuffer = _curGPUFBO->isOffscreen ? _curGPUFBO->vkFramebuffer :
+ _curGPUFBO->swapchain->vkSwapchainFramebuffers[_curGPUFBO->swapchain->curImageIndex];
+ passBeginInfo.renderArea.extent.width = renderArea.width;
+ passBeginInfo.renderArea.extent.height = renderArea.height;
+ passBeginInfo.clearValueCount = clearValues.size();
+ passBeginInfo.pClearValues = clearValues.data();
+
+ vkCmdBeginRenderPass(_gpuCommandBuffer->vkCommandBuffer, &passBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+ VkViewport viewport{ (float)renderArea.x, (float)(renderArea.height - renderArea.y), (float)renderArea.width, -(float)renderArea.height, 0, 1 };
+ vkCmdSetViewport(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &viewport);
+
+ VkRect2D scissor{ { renderArea.x, renderArea.y }, { renderArea.width, renderArea.height } };
+ vkCmdSetScissor(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &scissor);
+}
+
+void CCVKCommandBuffer::endRenderPass()
+{
+ vkCmdEndRenderPass(_gpuCommandBuffer->vkCommandBuffer);
+
+ auto &renderPass = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuRenderPass : _curGPUFBO->swapchain->renderPass;
+ auto &barriers = renderPass->endBarriers;
+ auto attachmentCount = barriers.size();
+
+ if (attachmentCount)
+ {
+ for (uint32_t i = 0u; i < attachmentCount - 1; i++)
+ {
+ barriers[i].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuColorViews[i]->gpuTexture->vkImage :
+ _curGPUFBO->swapchain->swapchainImages[_curGPUFBO->swapchain->curImageIndex];
+ }
+ barriers[attachmentCount - 1].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuDepthStencilView->gpuTexture->vkImage :
+ _curGPUFBO->swapchain->depthStencilImages[_curGPUFBO->swapchain->curImageIndex];
+
+ vkCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer,
+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+ VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_DEPENDENCY_BY_REGION_BIT,
+ 0, nullptr, 0, nullptr, barriers.size(), barriers.data());
+ }
+
+ _curGPUFBO = nullptr;
+}
+
+void CCVKCommandBuffer::bindPipelineState(GFXPipelineState* pso)
+{
+ _curGPUPipelineState = ((CCVKPipelineState*)pso)->gpuPipelineState();
+ vkCmdBindPipeline(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, _curGPUPipelineState->vkPipeline);
+ _isStateInvalid = true;
+}
+
+void CCVKCommandBuffer::bindBindingLayout(GFXBindingLayout* layout)
+{
+ _curGPUBlendLayout = ((CCVKBindingLayout*)layout)->gpuBindingLayout();
+ _isStateInvalid = true;
+}
+
+void CCVKCommandBuffer::bindInputAssembler(GFXInputAssembler* ia)
+{
+ auto gpuInputAssembler = ((CCVKInputAssembler*)ia)->gpuInputAssembler();
+
+ vkCmdBindVertexBuffers(_gpuCommandBuffer->vkCommandBuffer, 0, gpuInputAssembler->vertexBuffers.size(),
+ gpuInputAssembler->vertexBuffers.data(), gpuInputAssembler->vertexBufferOffsets.data());
+
+ if (gpuInputAssembler->gpuIndexBuffer)
+ {
+ vkCmdBindIndexBuffer(_gpuCommandBuffer->vkCommandBuffer, gpuInputAssembler->gpuIndexBuffer->vkBuffer, 0,
+ gpuInputAssembler->gpuIndexBuffer->stride == 32 ? VK_INDEX_TYPE_UINT32 : VK_INDEX_TYPE_UINT16);
+ }
+}
+
+void CCVKCommandBuffer::setViewport(const GFXViewport& vp)
+{
+ if (_curViewport != vp)
+ {
+ _curViewport = vp;
+ VkViewport viewport{ (float)vp.left, (float)vp.top, (float)vp.width, (float)vp.height, vp.minDepth, vp.maxDepth };
+ vkCmdSetViewport(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &viewport);
+ }
+}
+
+void CCVKCommandBuffer::setScissor(const GFXRect& rect)
+{
+ if (_curScissor != rect)
+ {
+ _curScissor = rect;
+ VkRect2D scissor{ { rect.x, rect.y }, { rect.width, rect.height } };
+ vkCmdSetScissor(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &scissor);
+ }
+}
+
+void CCVKCommandBuffer::setLineWidth(const float width)
+{
+ if (math::IsNotEqualF(_curLineWidth, width))
+ {
+ _curLineWidth = width;
+ vkCmdSetLineWidth(_gpuCommandBuffer->vkCommandBuffer, width);
+ }
+}
+
+void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope)
+{
+ if (math::IsNotEqualF(_curDepthBias.constant, constant) ||
+ math::IsNotEqualF(_curDepthBias.clamp, clamp) ||
+ math::IsNotEqualF(_curDepthBias.slope, slope))
+ {
+ _curDepthBias.constant = constant;
+ _curDepthBias.clamp = clamp;
+ _curDepthBias.slope = slope;
+ vkCmdSetDepthBias(_gpuCommandBuffer->vkCommandBuffer, constant, clamp, slope);
+ }
+}
+
+void CCVKCommandBuffer::setBlendConstants(const GFXColor& constants)
+{
+ if (math::IsNotEqualF(_curBlendConstants.r, constants.r) ||
+ math::IsNotEqualF(_curBlendConstants.g, constants.g) ||
+ math::IsNotEqualF(_curBlendConstants.b, constants.b) ||
+ math::IsNotEqualF(_curBlendConstants.a, constants.a))
+ {
+ _curBlendConstants.r = constants.r;
+ _curBlendConstants.g = constants.g;
+ _curBlendConstants.b = constants.b;
+ _curBlendConstants.a = constants.a;
+ vkCmdSetBlendConstants(_gpuCommandBuffer->vkCommandBuffer, reinterpret_cast(&constants));
+ }
+}
+
+void CCVKCommandBuffer::setDepthBound(float minBounds, float maxBounds)
+{
+ if (math::IsNotEqualF(_curDepthBounds.minBounds, minBounds) ||
+ math::IsNotEqualF(_curDepthBounds.maxBounds, maxBounds))
+ {
+ _curDepthBounds.minBounds = minBounds;
+ _curDepthBounds.maxBounds = maxBounds;
+ vkCmdSetDepthBounds(_gpuCommandBuffer->vkCommandBuffer, minBounds, maxBounds);
+ }
+}
+
+void CCVKCommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask)
+{
+ if ((_curStencilWriteMask.face != face) ||
+ (_curStencilWriteMask.write_mask != mask))
+ {
+ _curStencilWriteMask.face = face;
+ _curStencilWriteMask.write_mask = mask;
+ vkCmdSetStencilWriteMask(_gpuCommandBuffer->vkCommandBuffer,
+ face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT, mask);
+ }
+}
+
+void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference, uint mask)
+{
+ if ((_curStencilCompareMask.face != face) ||
+ (_curStencilCompareMask.reference != reference) ||
+ (_curStencilCompareMask.compareMask != mask))
+ {
+ _curStencilCompareMask.face = face;
+ _curStencilCompareMask.reference = reference;
+ _curStencilCompareMask.compareMask = mask;
+
+ VkStencilFaceFlagBits vkFace = (face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT);
+ vkCmdSetStencilReference(_gpuCommandBuffer->vkCommandBuffer, vkFace, reference);
+ vkCmdSetStencilCompareMask(_gpuCommandBuffer->vkCommandBuffer, vkFace, mask);
+ }
+}
+
+void CCVKCommandBuffer::draw(GFXInputAssembler* ia)
+{
+ if ((_type == GFXCommandBufferType::PRIMARY && _curGPUFBO) ||
+ (_type == GFXCommandBufferType::SECONDARY))
+ {
+ if (_isStateInvalid)
+ {
+ BindStates();
+ }
+
+ CCVKGPUInputAssembler* gpuInputAssembler = ((CCVKInputAssembler*)ia)->gpuInputAssembler();
+ GFXDrawInfo drawInfo;
+
+ if (gpuInputAssembler->gpuIndirectBuffer)
+ {
+ // TODO
+ }
+ else
+ {
+ ((CCVKInputAssembler*)ia)->extractDrawInfo(drawInfo);
+
+ if (gpuInputAssembler->gpuIndexBuffer && drawInfo.indexCount >= 0)
+ {
+ vkCmdDrawIndexed(_gpuCommandBuffer->vkCommandBuffer, drawInfo.indexCount, std::max(drawInfo.instanceCount, 1u),
+ drawInfo.firstIndex, drawInfo.vertexOffset, drawInfo.firstInstance);
+ }
+ else
+ {
+ vkCmdDraw(_gpuCommandBuffer->vkCommandBuffer, drawInfo.vertexCount, std::max(drawInfo.instanceCount, 1u),
+ drawInfo.firstVertex, drawInfo.firstInstance);
+ }
+ }
+ }
+ else
+ {
+ CC_LOG_ERROR("Command 'draw' must be recorded inside a render pass.");
+ }
+}
+
+void CCVKCommandBuffer::updateBuffer(GFXBuffer* buff, void* data, uint size, uint offset)
+{
+ if ((_type == GFXCommandBufferType::PRIMARY && _curGPUFBO) ||
+ (_type == GFXCommandBufferType::SECONDARY))
+ {
+ }
+ else
+ {
+ CC_LOG_ERROR("Command 'updateBuffer' must be recorded inside a render pass.");
+ }
+}
+
+void CCVKCommandBuffer::copyBufferToTexture(GFXBuffer* src, GFXTexture* dst, GFXTextureLayout layout, const GFXBufferTextureCopyList& regions)
+{
+ if ((_type == GFXCommandBufferType::PRIMARY && _curGPUFBO) ||
+ (_type == GFXCommandBufferType::SECONDARY))
+ {
+ }
+ else
+ {
+ CC_LOG_ERROR("Command 'copyBufferToTexture' must be recorded inside a render pass.");
+ }
+}
+
+void CCVKCommandBuffer::execute(const std::vector& cmd_buffs, uint32_t count)
+{
+ for (uint i = 0; i < count; ++i)
+ {
+ CCVKCommandBuffer* cmd_buff = (CCVKCommandBuffer*)cmd_buffs[i];
+
+ _numDrawCalls += cmd_buff->getNumDrawCalls();
+ _numInstances += cmd_buff->getNumInstances();
+ _numTriangles += cmd_buff->getNumTris();
+ }
+}
+
+void CCVKCommandBuffer::BindStates()
+{
+ _isStateInvalid = false;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h
new file mode 100644
index 0000000000..9216cfb977
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h
@@ -0,0 +1,67 @@
+#ifndef CC_GFXVULKAN_CCVK_COMMAND_BUFFER_H_
+#define CC_GFXVULKAN_CCVK_COMMAND_BUFFER_H_
+
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+class CC_VULKAN_API CCVKCommandBuffer : public GFXCommandBuffer
+{
+public:
+ CCVKCommandBuffer(GFXDevice* device);
+ ~CCVKCommandBuffer();
+
+ friend class CCVKQueue;
+
+public:
+ bool initialize(const GFXCommandBufferInfo& info);
+ void destroy();
+
+ void begin();
+ void end();
+ void beginRenderPass(GFXFramebuffer* fbo, const GFXRect& render_area, GFXClearFlags clear_flags, const std::vector& colors, float depth, int stencil);
+ void endRenderPass();
+ void bindPipelineState(GFXPipelineState* pso);
+ void bindBindingLayout(GFXBindingLayout* layout);
+ void bindInputAssembler(GFXInputAssembler* ia);
+ void setViewport(const GFXViewport& vp);
+ void setScissor(const GFXRect& rect);
+ void setLineWidth(const float width);
+ void setDepthBias(float constant, float clamp, float slope);
+ void setBlendConstants(const GFXColor& constants);
+ void setDepthBound(float min_bounds, float max_bounds);
+ void setStencilWriteMask(GFXStencilFace face, uint mask);
+ void setStencilCompareMask(GFXStencilFace face, int reference, uint mask);
+ void draw(GFXInputAssembler* ia);
+ void updateBuffer(GFXBuffer* buff, void* data, uint size, uint offset);
+ void copyBufferToTexture(GFXBuffer* src, GFXTexture* dst, GFXTextureLayout layout, const GFXBufferTextureCopyList& regions);
+ void execute(const std::vector& cmd_buffs, uint32_t count);
+
+ CCVKGPUCommandBuffer* gpuCommandBuffer() const { return _gpuCommandBuffer; }
+
+private:
+ void BindStates();
+
+private:
+ CCVKGPUCommandBuffer* _gpuCommandBuffer = nullptr;
+
+ CCVKGPUPipelineState* _curGPUPipelineState = nullptr;
+ CCVKGPUBindingLayout* _curGPUBlendLayout = nullptr;
+ CCVKGPUInputAssembler* _curGPUInputAssember = nullptr;
+
+ CCVKGPUFramebuffer* _curGPUFBO = nullptr;
+
+ GFXViewport _curViewport;
+ GFXRect _curScissor;
+ float _curLineWidth = 1.0f;
+ CCVKDepthBias _curDepthBias;
+ GFXColor _curBlendConstants;
+ CCVKDepthBounds _curDepthBounds;
+ CCVKStencilWriteMask _curStencilWriteMask;
+ CCVKStencilCompareMask _curStencilCompareMask;
+ bool _isStateInvalid = false;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKCommands.cc b/native/cocos/renderer/gfx-vulkan/VKCommands.cc
new file mode 100644
index 0000000000..9134136e2b
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKCommands.cc
@@ -0,0 +1,1182 @@
+#include "VKStd.h"
+#include "VKCommands.h"
+#include "VKDevice.h"
+#include "VKQueue.h"
+#include "VKContext.h"
+#include "VKStateCache.h"
+#include "VKSPIRV.h"
+
+#define BUFFER_OFFSET(idx) (static_cast(0) + (idx))
+
+NS_CC_BEGIN
+
+namespace
+{
+ VkFormat MapVkFormat(GFXFormat format)
+ {
+ switch (format)
+ {
+ case GFXFormat::R8: return VK_FORMAT_R8_UNORM;
+ case GFXFormat::R8SN: return VK_FORMAT_R8_SNORM;
+ case GFXFormat::R8UI: return VK_FORMAT_R8_UINT;
+ case GFXFormat::R8I: return VK_FORMAT_R8_SINT;
+ case GFXFormat::RG8: return VK_FORMAT_R8G8_UNORM;
+ case GFXFormat::RG8SN: return VK_FORMAT_R8G8_SNORM;
+ case GFXFormat::RG8UI: return VK_FORMAT_R8G8_UINT;
+ case GFXFormat::RG8I: return VK_FORMAT_R8G8_SINT;
+ case GFXFormat::RGB8: return VK_FORMAT_R8G8B8_UNORM;
+ case GFXFormat::RGB8SN: return VK_FORMAT_R8G8B8_SNORM;
+ case GFXFormat::RGB8UI: return VK_FORMAT_R8G8B8_UINT;
+ case GFXFormat::RGB8I: return VK_FORMAT_R8G8B8_SINT;
+ case GFXFormat::RGBA8: return VK_FORMAT_R8G8B8A8_UNORM;
+ case GFXFormat::BGRA8: return VK_FORMAT_B8G8R8A8_UNORM;
+ case GFXFormat::RGBA8SN: return VK_FORMAT_R8G8B8A8_SNORM;
+ case GFXFormat::RGBA8UI: return VK_FORMAT_R8G8B8A8_UINT;
+ case GFXFormat::RGBA8I: return VK_FORMAT_R8G8B8A8_SINT;
+ case GFXFormat::R16I: return VK_FORMAT_R16_SINT;
+ case GFXFormat::R16UI: return VK_FORMAT_R16_UINT;
+ case GFXFormat::R16F: return VK_FORMAT_R16_SFLOAT;
+ case GFXFormat::RG16I: return VK_FORMAT_R16G16_SINT;
+ case GFXFormat::RG16UI: return VK_FORMAT_R16G16_UINT;
+ case GFXFormat::RG16F: return VK_FORMAT_R16G16_SFLOAT;
+ case GFXFormat::RGB16I: return VK_FORMAT_R16G16B16_SINT;
+ case GFXFormat::RGB16UI: return VK_FORMAT_R16G16B16_UINT;
+ case GFXFormat::RGB16F: return VK_FORMAT_R16G16B16_SFLOAT;
+ case GFXFormat::RGBA16I: return VK_FORMAT_R16G16B16A16_SINT;
+ case GFXFormat::RGBA16UI: return VK_FORMAT_R16G16B16A16_UINT;
+ case GFXFormat::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT;
+ case GFXFormat::R32I: return VK_FORMAT_R32_SINT;
+ case GFXFormat::R32UI: return VK_FORMAT_R32_UINT;
+ case GFXFormat::R32F: return VK_FORMAT_R32_SFLOAT;
+ case GFXFormat::RG32I: return VK_FORMAT_R32G32_SINT;
+ case GFXFormat::RG32UI: return VK_FORMAT_R32G32_UINT;
+ case GFXFormat::RG32F: return VK_FORMAT_R32G32_SFLOAT;
+ case GFXFormat::RGB32I: return VK_FORMAT_R32G32B32_SINT;
+ case GFXFormat::RGB32UI: return VK_FORMAT_R32G32B32_UINT;
+ case GFXFormat::RGB32F: return VK_FORMAT_R32G32B32_SFLOAT;
+ case GFXFormat::RGBA32I: return VK_FORMAT_R32G32B32A32_SINT;
+ case GFXFormat::RGBA32UI: return VK_FORMAT_R32G32B32A32_UINT;
+ case GFXFormat::RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT;
+
+ case GFXFormat::R5G6B5: return VK_FORMAT_R5G6B5_UNORM_PACK16;
+ case GFXFormat::R11G11B10F: return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
+ case GFXFormat::RGB5A1: return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
+ case GFXFormat::RGBA4: return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
+ case GFXFormat::RGB10A2: return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+ case GFXFormat::RGB10A2UI: return VK_FORMAT_A2B10G10R10_UINT_PACK32;
+ case GFXFormat::RGB9E5: return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
+ case GFXFormat::D16: return VK_FORMAT_D16_UNORM;
+ case GFXFormat::D16S8: return VK_FORMAT_D16_UNORM_S8_UINT;
+ case GFXFormat::D24: return VK_FORMAT_X8_D24_UNORM_PACK32;
+ case GFXFormat::D24S8: return VK_FORMAT_D24_UNORM_S8_UINT;
+ case GFXFormat::D32F: return VK_FORMAT_D32_SFLOAT;
+ case GFXFormat::D32F_S8: return VK_FORMAT_D32_SFLOAT_S8_UINT;
+
+ case GFXFormat::BC1: return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
+ case GFXFormat::BC1_ALPHA: return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
+ case GFXFormat::BC1_SRGB: return VK_FORMAT_BC1_RGB_SRGB_BLOCK;
+ case GFXFormat::BC1_SRGB_ALPHA: return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
+ case GFXFormat::BC2: return VK_FORMAT_BC2_UNORM_BLOCK;
+ case GFXFormat::BC2_SRGB: return VK_FORMAT_BC2_SRGB_BLOCK;
+ case GFXFormat::BC3: return VK_FORMAT_BC3_UNORM_BLOCK;
+ case GFXFormat::BC3_SRGB: return VK_FORMAT_BC3_SRGB_BLOCK;
+ case GFXFormat::BC4: return VK_FORMAT_BC4_UNORM_BLOCK;
+ case GFXFormat::BC4_SNORM: return VK_FORMAT_BC4_SNORM_BLOCK;
+ case GFXFormat::BC5: return VK_FORMAT_BC5_UNORM_BLOCK;
+ case GFXFormat::BC5_SNORM: return VK_FORMAT_BC5_SNORM_BLOCK;
+ case GFXFormat::BC6H_UF16: return VK_FORMAT_BC6H_UFLOAT_BLOCK;
+ case GFXFormat::BC6H_SF16: return VK_FORMAT_BC6H_SFLOAT_BLOCK;
+ case GFXFormat::BC7: return VK_FORMAT_BC7_UNORM_BLOCK;
+ case GFXFormat::BC7_SRGB: return VK_FORMAT_BC7_SRGB_BLOCK;
+
+ case GFXFormat::ETC2_RGB8: return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+ case GFXFormat::ETC2_SRGB8: return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
+ case GFXFormat::ETC2_RGB8_A1: return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
+ case GFXFormat::ETC2_SRGB8_A1: return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
+ case GFXFormat::ETC2_RGBA8: return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
+ case GFXFormat::ETC2_SRGB8_A8: return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
+ case GFXFormat::EAC_R11: return VK_FORMAT_EAC_R11_UNORM_BLOCK;
+ case GFXFormat::EAC_R11SN: return VK_FORMAT_EAC_R11_SNORM_BLOCK;
+ case GFXFormat::EAC_RG11: return VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
+ case GFXFormat::EAC_RG11SN: return VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
+
+ case GFXFormat::PVRTC_RGB2: return VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
+ case GFXFormat::PVRTC_RGBA2: return VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
+ case GFXFormat::PVRTC_RGB4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
+ case GFXFormat::PVRTC_RGBA4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
+ case GFXFormat::PVRTC2_2BPP: return VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG;
+ case GFXFormat::PVRTC2_4BPP: return VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXFormat, convert to VkFormat failed.");
+ return VK_FORMAT_B8G8R8A8_UNORM;
+ }
+ }
+ }
+
+ VkSampleCountFlagBits MapVkSampleCount(uint sampleCount)
+ {
+ if (sampleCount == 1) return VK_SAMPLE_COUNT_1_BIT;
+ else if (sampleCount == 2) return VK_SAMPLE_COUNT_2_BIT;
+ else if (sampleCount == 4) return VK_SAMPLE_COUNT_4_BIT;
+ else if (sampleCount == 8) return VK_SAMPLE_COUNT_8_BIT;
+ else if (sampleCount == 16) return VK_SAMPLE_COUNT_16_BIT;
+ else if (sampleCount == 32) return VK_SAMPLE_COUNT_32_BIT;
+ else if (sampleCount == 64) return VK_SAMPLE_COUNT_64_BIT;
+ else return VK_SAMPLE_COUNT_1_BIT;
+ }
+
+ VkAttachmentLoadOp MapVkLoadOp(GFXLoadOp loadOp)
+ {
+ switch (loadOp)
+ {
+ case GFXLoadOp::CLEAR: return VK_ATTACHMENT_LOAD_OP_CLEAR;
+ case GFXLoadOp::LOAD: return VK_ATTACHMENT_LOAD_OP_LOAD;
+ case GFXLoadOp::DISCARD: return VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXLoadOp, convert to VkLoadOp failed.");
+ return VK_ATTACHMENT_LOAD_OP_LOAD;
+ }
+ }
+ }
+
+ VkAttachmentStoreOp MapVkStoreOp(GFXStoreOp storeOp)
+ {
+ switch (storeOp)
+ {
+ case GFXStoreOp::STORE: return VK_ATTACHMENT_STORE_OP_STORE;
+ case GFXStoreOp::DISCARD: return VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXStoreOp, convert to VkStoreOp failed.");
+ return VK_ATTACHMENT_STORE_OP_STORE;
+ }
+ }
+ }
+
+ VkImageLayout MapVkImageLayout(GFXTextureLayout layout)
+ {
+ switch (layout)
+ {
+ case GFXTextureLayout::UNDEFINED: return VK_IMAGE_LAYOUT_UNDEFINED;
+ case GFXTextureLayout::GENERAL: return VK_IMAGE_LAYOUT_GENERAL;
+ case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ case GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+ case GFXTextureLayout::DEPTH_STENCIL_READONLY_OPTIMAL: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+ case GFXTextureLayout::SHADER_READONLY_OPTIMAL: return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ case GFXTextureLayout::TRANSFER_SRC_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ case GFXTextureLayout::PREINITIALIZED: return VK_IMAGE_LAYOUT_PREINITIALIZED;
+ case GFXTextureLayout::PRESENT_SRC: return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed.");
+ return VK_IMAGE_LAYOUT_GENERAL;
+ }
+ }
+ }
+
+ VkAccessFlags MapVkAccessFlags(GFXTextureLayout layout)
+ {
+ switch (layout)
+ {
+ case GFXTextureLayout::UNDEFINED: return 0;
+ case GFXTextureLayout::GENERAL: return 0;
+ case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ case GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+ case GFXTextureLayout::DEPTH_STENCIL_READONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+ case GFXTextureLayout::SHADER_READONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT;
+ case GFXTextureLayout::TRANSFER_SRC_OPTIMAL: return VK_ACCESS_TRANSFER_READ_BIT;
+ case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT;
+ case GFXTextureLayout::PREINITIALIZED: return 0;
+ case GFXTextureLayout::PRESENT_SRC: return 0;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed.");
+ return 0;
+ }
+ }
+ }
+
+ VkPipelineBindPoint MapVkPipelineBindPoint(GFXPipelineBindPoint bindPoint)
+ {
+ switch (bindPoint)
+ {
+ case GFXPipelineBindPoint::GRAPHICS: return VK_PIPELINE_BIND_POINT_GRAPHICS;
+ case GFXPipelineBindPoint::COMPUTE: return VK_PIPELINE_BIND_POINT_COMPUTE;
+ case GFXPipelineBindPoint::RAY_TRACING: return VK_PIPELINE_BIND_POINT_RAY_TRACING_NV;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXPipelineBindPoint, convert to VkPipelineBindPoint failed.");
+ return VK_PIPELINE_BIND_POINT_GRAPHICS;
+ }
+ }
+ }
+
+ VkBufferUsageFlagBits MapVkBufferUsageFlagBits(GFXBufferUsage usage)
+ {
+ uint32_t flags = 0;
+ if (usage & GFXBufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+ if (usage & GFXBufferUsage::TRANSFER_DST) flags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+ if (usage & GFXBufferUsage::INDEX) flags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
+ if (usage & GFXBufferUsage::VERTEX) flags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+ if (usage & GFXBufferUsage::UNIFORM) flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+ if (usage & GFXBufferUsage::STORAGE) flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+ if (usage & GFXBufferUsage::INDIRECT) flags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
+ return (VkBufferUsageFlagBits)flags;
+ }
+
+ VkImageType MapVkImageType(GFXTextureType type)
+ {
+ switch (type)
+ {
+ case GFXTextureType::TEX1D: return VK_IMAGE_TYPE_1D;
+ case GFXTextureType::TEX2D: return VK_IMAGE_TYPE_2D;
+ case GFXTextureType::TEX3D: return VK_IMAGE_TYPE_3D;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed.");
+ return VK_IMAGE_TYPE_2D;
+ }
+ }
+ }
+
+ VkSampleCountFlagBits MapVkSampleCount(GFXSampleCount count)
+ {
+ switch (count)
+ {
+ case GFXSampleCount::X1: return VK_SAMPLE_COUNT_1_BIT;
+ case GFXSampleCount::X2: return VK_SAMPLE_COUNT_2_BIT;
+ case GFXSampleCount::X4: return VK_SAMPLE_COUNT_4_BIT;
+ case GFXSampleCount::X8: return VK_SAMPLE_COUNT_8_BIT;
+ case GFXSampleCount::X16: return VK_SAMPLE_COUNT_16_BIT;
+ case GFXSampleCount::X32: return VK_SAMPLE_COUNT_32_BIT;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed.");
+ return VK_SAMPLE_COUNT_1_BIT;
+ }
+ }
+ }
+
+ VkImageUsageFlagBits MapVkImageUsageFlagBits(GFXTextureUsage usage)
+ {
+ uint32_t flags = 0;
+ if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+ if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+ if (usage & GFXTextureUsage::SAMPLED) flags |= VK_IMAGE_USAGE_SAMPLED_BIT;
+ if (usage & GFXTextureUsage::STORAGE) flags |= VK_IMAGE_USAGE_STORAGE_BIT;
+ if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+ if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+ if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
+ if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+ return (VkImageUsageFlagBits)flags;
+ }
+
+ uint32_t selectMemoryType(const VkPhysicalDeviceMemoryProperties& memoryProperties, uint32_t memoryTypeBits, VkMemoryPropertyFlags flags)
+ {
+ for (uint32_t i = 0; i < memoryProperties.memoryTypeCount; ++i)
+ if ((memoryTypeBits & (1 << i)) != 0 && (memoryProperties.memoryTypes[i].propertyFlags & flags) == flags)
+ return i;
+
+ CCASSERT(false, "No compatible memory type found.");
+ return ~0u;
+ }
+
+ VkImageCreateFlags MapVkImageCreateFlags(GFXTextureViewType type)
+ {
+ uint32_t res = 0;
+ switch (type)
+ {
+ case cocos2d::GFXTextureViewType::CUBE: res |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; break;
+ case cocos2d::GFXTextureViewType::TV2D_ARRAY: res |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; break;
+ }
+ return (VkImageCreateFlags)res;
+ }
+
+ VkImageViewType MapVkImageViewType(GFXTextureViewType viewType)
+ {
+ switch (viewType)
+ {
+ case GFXTextureViewType::TV1D: return VK_IMAGE_VIEW_TYPE_1D;
+ case GFXTextureViewType::TV1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
+ case GFXTextureViewType::TV2D: return VK_IMAGE_VIEW_TYPE_2D;
+ case GFXTextureViewType::TV2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+ case GFXTextureViewType::TV3D: return VK_IMAGE_VIEW_TYPE_3D;
+ case GFXTextureViewType::CUBE: return VK_IMAGE_VIEW_TYPE_CUBE;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXTextureViewType, convert to VkImageViewType failed.");
+ return VK_IMAGE_VIEW_TYPE_2D;
+ }
+ }
+ }
+
+ VkCommandBufferLevel MapVkCommandBufferLevel(GFXCommandBufferType type)
+ {
+ switch (type)
+ {
+ case GFXCommandBufferType::PRIMARY: return VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+ case GFXCommandBufferType::SECONDARY: return VK_COMMAND_BUFFER_LEVEL_SECONDARY;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXCommandBufferType, convert to VkCommandBufferLevel failed.");
+ return VK_COMMAND_BUFFER_LEVEL_SECONDARY;
+ }
+ }
+ }
+
+ VkDescriptorType MapVkDescriptorType(GFXBindingType type)
+ {
+ switch (type)
+ {
+ case cocos2d::GFXBindingType::UNIFORM_BUFFER: return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ case cocos2d::GFXBindingType::SAMPLER: return VK_DESCRIPTOR_TYPE_SAMPLER;
+ case cocos2d::GFXBindingType::STORAGE_BUFFER: return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXBindingType, convert to VkDescriptorType failed.");
+ return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+ }
+ }
+ }
+
+ void InsertVkDynamicStates(vector::type& out, const vector::type& dynamicStates)
+ {
+ for (auto dynamicState : dynamicStates)
+ {
+ switch (dynamicState)
+ {
+ case GFXDynamicState::VIEWPORT: break; // we make this dynamic by default
+ case GFXDynamicState::SCISSOR: break; // we make this dynamic by default
+ case GFXDynamicState::LINE_WIDTH: out.push_back(VK_DYNAMIC_STATE_LINE_WIDTH); break;
+ case GFXDynamicState::DEPTH_BIAS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BIAS); break;
+ case GFXDynamicState::BLEND_CONSTANTS: out.push_back(VK_DYNAMIC_STATE_BLEND_CONSTANTS); break;
+ case GFXDynamicState::DEPTH_BOUNDS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BOUNDS); break;
+ case GFXDynamicState::STENCIL_WRITE_MASK: out.push_back(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK); break;
+ case GFXDynamicState::STENCIL_COMPARE_MASK:
+ out.push_back(VK_DYNAMIC_STATE_STENCIL_REFERENCE);
+ out.push_back(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK);
+ break;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXPrimitiveMode, convert to VkPrimitiveTopology failed.");
+ break;
+ }
+ }
+ }
+ }
+
+ VkColorComponentFlags MapVkColorComponentFlags(GFXColorMask colorMask)
+ {
+ uint32_t flags = 0;
+ if (colorMask & GFXColorMask::R) flags |= VK_COLOR_COMPONENT_R_BIT;
+ if (colorMask & GFXColorMask::G) flags |= VK_COLOR_COMPONENT_G_BIT;
+ if (colorMask & GFXColorMask::B) flags |= VK_COLOR_COMPONENT_B_BIT;
+ if (colorMask & GFXColorMask::A) flags |= VK_COLOR_COMPONENT_A_BIT;
+ if (colorMask & GFXColorMask::ALL) flags |= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+ return (VkColorComponentFlags)flags;
+ }
+
+ const VkShaderStageFlagBits VK_SHADER_TYPES[] =
+ {
+ VK_SHADER_STAGE_VERTEX_BIT,
+ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
+ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
+ VK_SHADER_STAGE_GEOMETRY_BIT,
+ VK_SHADER_STAGE_FRAGMENT_BIT,
+ VK_SHADER_STAGE_COMPUTE_BIT,
+ };
+
+ const VkPrimitiveTopology VK_PRIMITIVE_MODES[] =
+ {
+ VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // POINT_LIST
+ VK_PRIMITIVE_TOPOLOGY_LINE_LIST, // LINE_LIST
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, // LINE_STRIP
+ (VkPrimitiveTopology)0, // LINE_LOOP
+ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, // LINE_LIST_ADJACENCY
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, // LINE_STRIP_ADJACENCY
+ (VkPrimitiveTopology)0, // ISO_LINE_LIST
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // TRIANGLE_LIST
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // TRIANGLE_STRIP
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, // TRIANGLE_FAN
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, // TRIANGLE_LIST_ADJACENCY
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, // TRIANGLE_STRIP_ADJACENCY,
+ (VkPrimitiveTopology)0, // TRIANGLE_PATCH_ADJACENCY,
+ VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, // QUAD_PATCH_LIST,
+ };
+
+ const VkCullModeFlags VK_CULL_MODES[] = {
+ VK_CULL_MODE_NONE,
+ VK_CULL_MODE_FRONT_BIT,
+ VK_CULL_MODE_BACK_BIT,
+ };
+
+ const VkPolygonMode VK_POLYGON_MODES[] =
+ {
+ VK_POLYGON_MODE_FILL,
+ VK_POLYGON_MODE_LINE,
+ VK_POLYGON_MODE_POINT,
+ };
+
+ const VkCompareOp VK_CMP_FUNCS[] =
+ {
+ VK_COMPARE_OP_NEVER,
+ VK_COMPARE_OP_LESS,
+ VK_COMPARE_OP_EQUAL,
+ VK_COMPARE_OP_LESS_OR_EQUAL,
+ VK_COMPARE_OP_GREATER,
+ VK_COMPARE_OP_NOT_EQUAL,
+ VK_COMPARE_OP_GREATER_OR_EQUAL,
+ VK_COMPARE_OP_ALWAYS,
+ };
+
+ const VkStencilOp VK_STENCIL_OPS[] =
+ {
+ VK_STENCIL_OP_ZERO,
+ VK_STENCIL_OP_KEEP,
+ VK_STENCIL_OP_REPLACE,
+ VK_STENCIL_OP_INCREMENT_AND_CLAMP,
+ VK_STENCIL_OP_DECREMENT_AND_CLAMP,
+ VK_STENCIL_OP_INVERT,
+ VK_STENCIL_OP_INCREMENT_AND_WRAP,
+ VK_STENCIL_OP_DECREMENT_AND_WRAP,
+ };
+
+ const VkBlendOp VK_BLEND_OPS[] =
+ {
+ VK_BLEND_OP_ADD,
+ VK_BLEND_OP_SUBTRACT,
+ VK_BLEND_OP_REVERSE_SUBTRACT,
+ VK_BLEND_OP_ADD,
+ VK_BLEND_OP_ADD,
+ };
+
+ const VkBlendFactor VK_BLEND_FACTORS[] =
+ {
+ VK_BLEND_FACTOR_ZERO,
+ VK_BLEND_FACTOR_ONE,
+ VK_BLEND_FACTOR_SRC_ALPHA,
+ VK_BLEND_FACTOR_DST_ALPHA,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
+ VK_BLEND_FACTOR_SRC_COLOR,
+ VK_BLEND_FACTOR_DST_COLOR,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
+ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
+ VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
+ VK_BLEND_FACTOR_CONSTANT_COLOR,
+ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
+ VK_BLEND_FACTOR_CONSTANT_ALPHA,
+ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
+ };
+}
+
+void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass)
+{
+ uint32_t colorAttachmentCount = gpuRenderPass->colorAttachments.size();
+ vector::type attachmentDescriptions(colorAttachmentCount + 1);
+ gpuRenderPass->clearValues.resize(colorAttachmentCount + 1);
+ gpuRenderPass->beginBarriers.resize(colorAttachmentCount + 1, { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER });
+ gpuRenderPass->endBarriers.resize(colorAttachmentCount + 1, { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER });
+ for (uint32_t i = 0u; i < colorAttachmentCount; i++)
+ {
+ auto &attachment = gpuRenderPass->colorAttachments[i];
+ auto beginLayout = MapVkImageLayout(attachment.beginLayout);
+ auto endLayout = MapVkImageLayout(attachment.endLayout);
+ auto beginAccessMask = MapVkAccessFlags(attachment.beginLayout);
+ auto endAccessMask = MapVkAccessFlags(attachment.endLayout);
+ attachmentDescriptions[i].format = MapVkFormat(attachment.format);
+ attachmentDescriptions[i].samples = MapVkSampleCount(attachment.sampleCount);
+ attachmentDescriptions[i].loadOp = MapVkLoadOp(attachment.loadOp);
+ attachmentDescriptions[i].storeOp = MapVkStoreOp(attachment.storeOp);
+ attachmentDescriptions[i].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+ attachmentDescriptions[i].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ attachmentDescriptions[i].initialLayout = beginLayout;
+ attachmentDescriptions[i].finalLayout = endLayout;
+
+ auto &beginBarrier = gpuRenderPass->beginBarriers[i];
+ beginBarrier.srcAccessMask = 0;
+ beginBarrier.dstAccessMask = beginAccessMask;
+ beginBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ beginBarrier.newLayout = beginLayout;
+ beginBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ beginBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ beginBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ beginBarrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
+ beginBarrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
+
+ auto &endBarrier = gpuRenderPass->endBarriers[i];
+ endBarrier.srcAccessMask = beginAccessMask;
+ endBarrier.dstAccessMask = endAccessMask;
+ endBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; // TODO: we get a layout mismatch validation error if pass beginLayout here, probably a bug in the validation layer
+ endBarrier.newLayout = endLayout;
+ endBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ endBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ endBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ endBarrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
+ endBarrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
+ }
+ auto &depthStencilAttachment = gpuRenderPass->depthStencilAttachment;
+ auto beginLayout = MapVkImageLayout(depthStencilAttachment.beginLayout);
+ auto endLayout = MapVkImageLayout(depthStencilAttachment.endLayout);
+ auto beginAccessMask = MapVkAccessFlags(depthStencilAttachment.beginLayout);
+ auto endAccessMask = MapVkAccessFlags(depthStencilAttachment.endLayout);
+ auto aspectMask = GFX_FORMAT_INFOS[(uint)depthStencilAttachment.format].hasStencil ?
+ VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
+ attachmentDescriptions[colorAttachmentCount].format = MapVkFormat(depthStencilAttachment.format);
+ attachmentDescriptions[colorAttachmentCount].samples = MapVkSampleCount(depthStencilAttachment.sampleCount);
+ attachmentDescriptions[colorAttachmentCount].loadOp = MapVkLoadOp(depthStencilAttachment.depthLoadOp);
+ attachmentDescriptions[colorAttachmentCount].storeOp = MapVkStoreOp(depthStencilAttachment.depthStoreOp);
+ attachmentDescriptions[colorAttachmentCount].stencilLoadOp = MapVkLoadOp(depthStencilAttachment.stencilLoadOp);
+ attachmentDescriptions[colorAttachmentCount].stencilStoreOp = MapVkStoreOp(depthStencilAttachment.stencilStoreOp);
+ attachmentDescriptions[colorAttachmentCount].initialLayout = MapVkImageLayout(depthStencilAttachment.beginLayout);
+ attachmentDescriptions[colorAttachmentCount].finalLayout = MapVkImageLayout(depthStencilAttachment.endLayout);
+
+ auto &beginBarrier = gpuRenderPass->beginBarriers[colorAttachmentCount];
+ beginBarrier.srcAccessMask = 0;
+ beginBarrier.dstAccessMask = beginAccessMask;
+ beginBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ beginBarrier.newLayout = beginLayout;
+ beginBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ beginBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ beginBarrier.subresourceRange.aspectMask = aspectMask;
+ beginBarrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
+ beginBarrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
+
+ auto &endBarrier = gpuRenderPass->endBarriers[colorAttachmentCount];
+ endBarrier.srcAccessMask = beginAccessMask;
+ endBarrier.dstAccessMask = endAccessMask;
+ endBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; // TODO: we get a layout mismatch validation error if pass beginLayout here, probably a bug in the validation layer
+ endBarrier.newLayout = endLayout;
+ endBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ endBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+ endBarrier.subresourceRange.aspectMask = aspectMask;
+ endBarrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
+ endBarrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
+
+ uint32_t subpassCount = gpuRenderPass->subPasses.size();
+ vector::type subpassDescriptions(1, { VK_PIPELINE_BIND_POINT_GRAPHICS });
+ vector::type attachmentReferences;
+ if (subpassCount) // pass on user-specified subpasses
+ {
+ subpassDescriptions.resize(subpassCount);
+ for (uint32_t i = 0u; i < subpassCount; i++)
+ {
+ auto &subpass = gpuRenderPass->subPasses[i];
+ subpassDescriptions[i].pipelineBindPoint = MapVkPipelineBindPoint(subpass.bindPoint);
+ // TODO
+ }
+ }
+ else // generate a default subpass from attachment info
+ {
+ for (uint32_t i = 0u; i < colorAttachmentCount; i++)
+ {
+ attachmentReferences.push_back({ i, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL });
+ }
+ attachmentReferences.push_back({ colorAttachmentCount, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL });
+ subpassDescriptions[0].colorAttachmentCount = attachmentReferences.size() - 1;
+ subpassDescriptions[0].pColorAttachments = attachmentReferences.data();
+ subpassDescriptions[0].pDepthStencilAttachment = &attachmentReferences.back();
+ }
+
+ VkRenderPassCreateInfo renderPassCreateInfo{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
+ renderPassCreateInfo.attachmentCount = attachmentDescriptions.size();
+ renderPassCreateInfo.pAttachments = attachmentDescriptions.data();
+ renderPassCreateInfo.subpassCount = subpassDescriptions.size();
+ renderPassCreateInfo.pSubpasses = subpassDescriptions.data();
+
+ VK_CHECK(vkCreateRenderPass(device->gpuDevice()->vkDevice, &renderPassCreateInfo, nullptr, &gpuRenderPass->vkRenderPass));
+}
+
+void CCVKCmdFuncDestroyRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass)
+{
+ if (gpuRenderPass->vkRenderPass != VK_NULL_HANDLE)
+ {
+ vkDestroyRenderPass(device->gpuDevice()->vkDevice, gpuRenderPass->vkRenderPass, nullptr);
+ gpuRenderPass->vkRenderPass = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncGetDeviceQueue(CCVKDevice* device, CCVKGPUQueue* gpuQueue)
+{
+ uint32_t queueType = 0;
+ VkBool32 needPresentable = VK_FALSE;
+ switch (gpuQueue->type)
+ {
+ case GFXQueueType::GRAPHICS: queueType = VK_QUEUE_GRAPHICS_BIT; needPresentable = VK_TRUE; break;
+ case GFXQueueType::COMPUTE: queueType = VK_QUEUE_COMPUTE_BIT; break;
+ case GFXQueueType::TRANSFER: queueType = VK_QUEUE_TRANSFER_BIT; break;
+ }
+
+ const CCVKGPUContext* context = ((CCVKContext*)device->getContext())->gpuContext();
+
+ size_t queueCount = context->queueFamilyProperties.size();
+ for (uint32_t i = 0U; i < queueCount; ++i)
+ {
+ const VkQueueFamilyProperties &properties = context->queueFamilyProperties[i];
+ const VkBool32 isPresentable = context->queueFamilyPresentables[i];
+ if (properties.queueCount > 0 && (properties.queueFlags & queueType) && (!needPresentable || isPresentable))
+ {
+ vkGetDeviceQueue(device->gpuDevice()->vkDevice, i, 0, &gpuQueue->vkQueue);
+ gpuQueue->queueFamilyIndex = i;
+ break;
+ }
+ }
+}
+
+void CCVKCmdFuncCreateCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool)
+{
+ VkCommandPoolCreateInfo createInfo{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
+ createInfo.queueFamilyIndex = ((CCVKQueue*)device->getQueue())->gpuQueue()->queueFamilyIndex;
+ createInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
+
+ VK_CHECK(vkCreateCommandPool(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuCommandPool->vkCommandPool));
+}
+
+void CCVKCmdFuncDestroyCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool)
+{
+ if (gpuCommandPool->vkCommandPool != VK_NULL_HANDLE)
+ {
+ vkDestroyCommandPool(device->gpuDevice()->vkDevice, gpuCommandPool->vkCommandPool, nullptr);
+ gpuCommandPool->vkCommandPool = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer)
+{
+ CCVKGPUCommandPool* commandPool = gpuCommandBuffer->commandPool;
+ VkCommandBufferLevel level = MapVkCommandBufferLevel(gpuCommandBuffer->type);
+
+ if (commandPool->commandBuffers[level].size())
+ {
+ gpuCommandBuffer->vkCommandBuffer = commandPool->commandBuffers[level].pop();
+ }
+ else
+ {
+ VkCommandBufferAllocateInfo allocateInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+ allocateInfo.commandPool = gpuCommandBuffer->commandPool->vkCommandPool;
+ allocateInfo.commandBufferCount = 1;
+ allocateInfo.level = level;
+
+ VK_CHECK(vkAllocateCommandBuffers(device->gpuDevice()->vkDevice, &allocateInfo, &gpuCommandBuffer->vkCommandBuffer));
+ }
+}
+
+void CCVKCmdFuncFreeCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer)
+{
+ VkCommandBufferLevel level = MapVkCommandBufferLevel(gpuCommandBuffer->type);
+
+ if (gpuCommandBuffer->vkCommandBuffer)
+ {
+ gpuCommandBuffer->commandPool->commandBuffers[level].push(gpuCommandBuffer->vkCommandBuffer);
+ gpuCommandBuffer->vkCommandBuffer = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncCreateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer)
+{
+ auto vkDevice = device->gpuDevice()->vkDevice;
+ bool isHostVisible = gpuBuffer->memUsage & GFXMemoryUsage::HOST;
+
+ VkBufferCreateInfo createInfo{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+ createInfo.size = gpuBuffer->size;
+ createInfo.usage = MapVkBufferUsageFlagBits(gpuBuffer->usage);
+
+ VK_CHECK(vkCreateBuffer(vkDevice, &createInfo, nullptr, &gpuBuffer->vkBuffer));
+
+ VkMemoryRequirements memoryRequirements;
+ vkGetBufferMemoryRequirements(vkDevice, gpuBuffer->vkBuffer, &memoryRequirements);
+
+ uint32_t memoryTypeIndex = selectMemoryType(
+ ((CCVKContext*)device->getContext())->gpuContext()->physicalDeviceMemoryProperties,
+ memoryRequirements.memoryTypeBits, isHostVisible ?
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT :
+ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+ VkMemoryAllocateInfo allocateInfo{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ allocateInfo.allocationSize = memoryRequirements.size;
+ allocateInfo.memoryTypeIndex = memoryTypeIndex;
+
+ VK_CHECK(vkAllocateMemory(vkDevice, &allocateInfo, nullptr, &gpuBuffer->vkDeviceMemory));
+
+ VK_CHECK(vkBindBufferMemory(vkDevice, gpuBuffer->vkBuffer, gpuBuffer->vkDeviceMemory, 0));
+
+ if (isHostVisible)
+ {
+ VK_CHECK(vkMapMemory(vkDevice, gpuBuffer->vkDeviceMemory, 0, gpuBuffer->size, 0, &gpuBuffer->buffer));
+ }
+}
+
+void CCVKCmdFuncDestroyBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer)
+{
+ auto vkDevice = device->gpuDevice()->vkDevice;
+
+ if (gpuBuffer->vkDeviceMemory)
+ {
+ vkFreeMemory(vkDevice, gpuBuffer->vkDeviceMemory, nullptr);
+ gpuBuffer->vkDeviceMemory = VK_NULL_HANDLE;
+ }
+
+ if (gpuBuffer->vkBuffer)
+ {
+ vkDestroyBuffer(vkDevice, gpuBuffer->vkBuffer, nullptr);
+ gpuBuffer->vkBuffer = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncResizeBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer)
+{
+ CCVKCmdFuncDestroyBuffer(device, gpuBuffer);
+ CCVKCmdFuncCreateBuffer(device, gpuBuffer);
+}
+
+void CCVKCmdFuncUpdateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer, void* buffer, uint offset, uint size)
+{
+ if (gpuBuffer->memUsage & GFXMemoryUsage::HOST)
+ {
+ memcpy((unsigned char*)gpuBuffer->buffer + offset, buffer, size);
+ }
+ else
+ {
+ //auto vkDevice = device->gpuDevice()->vkDevice;
+ // TODO
+ }
+}
+
+void CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture)
+{
+ auto vkDevice = device->gpuDevice()->vkDevice;
+
+ VkImageCreateInfo createInfo{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+ createInfo.flags = MapVkImageCreateFlags(gpuTexture->viewType);
+ createInfo.imageType = MapVkImageType(gpuTexture->type);
+ createInfo.format = MapVkFormat(gpuTexture->format);
+ createInfo.extent = { gpuTexture->width, gpuTexture->height, gpuTexture->depth };
+ createInfo.mipLevels = gpuTexture->mipLevel;
+ createInfo.arrayLayers = gpuTexture->arrayLayer;
+ createInfo.samples = MapVkSampleCount(gpuTexture->samples);
+ createInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+ createInfo.usage = MapVkImageUsageFlagBits(gpuTexture->usage);
+ createInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+ VK_CHECK(vkCreateImage(vkDevice, &createInfo, nullptr, &gpuTexture->vkImage));
+
+ VkMemoryRequirements memoryRequirements;
+ vkGetImageMemoryRequirements(vkDevice, gpuTexture->vkImage, &memoryRequirements);
+
+ uint32_t memoryTypeIndex = selectMemoryType(
+ ((CCVKContext*)device->getContext())->gpuContext()->physicalDeviceMemoryProperties,
+ memoryRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+ VkMemoryAllocateInfo allocateInfo{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ allocateInfo.allocationSize = memoryRequirements.size;
+ allocateInfo.memoryTypeIndex = memoryTypeIndex;
+
+ VK_CHECK(vkAllocateMemory(vkDevice, &allocateInfo, nullptr, &gpuTexture->vkDeviceMemory));
+
+ VK_CHECK(vkBindImageMemory(vkDevice, gpuTexture->vkImage, gpuTexture->vkDeviceMemory, 0));
+}
+
+void CCVKCmdFuncDestroyTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture)
+{
+ auto vkDevice = device->gpuDevice()->vkDevice;
+
+ if (gpuTexture->vkImage)
+ {
+ vkDestroyImage(vkDevice, gpuTexture->vkImage, nullptr);
+ gpuTexture->vkImage = VK_NULL_HANDLE;
+ }
+
+ if (gpuTexture->vkDeviceMemory)
+ {
+ vkFreeMemory(vkDevice, gpuTexture->vkDeviceMemory, nullptr);
+ gpuTexture->vkDeviceMemory = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncResizeTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture)
+{
+ CCVKCmdFuncDestroyTexture(device, gpuTexture);
+ CCVKCmdFuncCreateTexture(device, gpuTexture);
+}
+
+void CCVKCmdFuncCreateTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView)
+{
+ VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ auto &info = GFX_FORMAT_INFOS[(uint)gpuTextureView->format];
+ if (info.hasDepth) { aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; }
+ if (info.hasStencil) { aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT; }
+
+ VkImageViewCreateInfo createInfo{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ createInfo.image = gpuTextureView->gpuTexture->vkImage;
+ createInfo.viewType = MapVkImageViewType(gpuTextureView->type);
+ createInfo.format = MapVkFormat(gpuTextureView->format);
+ createInfo.subresourceRange.aspectMask = aspectMask;
+ createInfo.subresourceRange.baseMipLevel = gpuTextureView->baseLevel;
+ createInfo.subresourceRange.levelCount = gpuTextureView->levelCount;
+ createInfo.subresourceRange.baseArrayLayer = 0;
+ createInfo.subresourceRange.layerCount = gpuTextureView->gpuTexture->arrayLayer;
+
+ VK_CHECK(vkCreateImageView(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuTextureView->vkImageView));
+}
+
+void CCVKCmdFuncDestroyTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView)
+{
+ if (gpuTextureView->vkImageView != VK_NULL_HANDLE)
+ {
+ vkDestroyImageView(device->gpuDevice()->vkDevice, gpuTextureView->vkImageView, nullptr);
+ gpuTextureView->vkImageView = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncCreateSampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler)
+{
+
+}
+
+void CCVKCmdFuncDestroySampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler)
+{
+
+}
+
+void CCVKCmdFuncCreateShader(CCVKDevice* device, CCVKGPUShader* gpuShader)
+{
+ for (auto &stage : gpuShader->gpuStages)
+ {
+ auto spirv = GLSL2SPIRV(stage.type, "#version 450\n" + stage.source, ((CCVKContext*)device->getContext())->minorVersion());
+ VkShaderModuleCreateInfo createInfo{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
+ createInfo.codeSize = spirv.size() * sizeof(unsigned int);
+ createInfo.pCode = spirv.data();
+ VK_CHECK(vkCreateShaderModule(device->gpuDevice()->vkDevice, &createInfo, nullptr, &stage.vkShader));
+ }
+}
+
+void CCVKCmdFuncDestroyShader(CCVKDevice* device, CCVKGPUShader* gpuShader)
+{
+ for (auto &stage : gpuShader->gpuStages)
+ {
+ vkDestroyShaderModule(device->gpuDevice()->vkDevice, stage.vkShader, nullptr);
+ stage.vkShader = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncCreateInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler)
+{
+ auto vbCount = gpuInputAssembler->gpuVertexBuffers.size();
+ gpuInputAssembler->vertexBuffers.resize(vbCount);
+ gpuInputAssembler->vertexBufferOffsets.resize(vbCount);
+
+ for (uint32_t i = 0; i < vbCount; i++)
+ {
+ gpuInputAssembler->vertexBuffers[i] = gpuInputAssembler->gpuVertexBuffers[i]->vkBuffer;
+ gpuInputAssembler->vertexBufferOffsets[i] = 0;
+ }
+}
+
+void CCVKCmdFuncDestroyInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler)
+{
+ gpuInputAssembler->vertexBuffers.clear();
+ gpuInputAssembler->vertexBufferOffsets.clear();
+}
+
+void CCVKCmdFuncCreateFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer)
+{
+ if (!gpuFramebuffer->isOffscreen)
+ {
+ gpuFramebuffer->swapchain = device->gpuSwapchain();
+ return;
+ }
+
+ uint32_t colorViewCount = gpuFramebuffer->gpuColorViews.size();
+ vector::type attachments(colorViewCount + (gpuFramebuffer->gpuDepthStencilView ? 1 : 0));
+ for (uint32_t i = 0u; i < colorViewCount; i++)
+ {
+ attachments[i] = gpuFramebuffer->gpuColorViews[i]->vkImageView;
+ }
+ if (gpuFramebuffer->gpuDepthStencilView)
+ {
+ attachments[colorViewCount] = gpuFramebuffer->gpuDepthStencilView->vkImageView;
+ }
+
+ VkFramebufferCreateInfo createInfo{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+ createInfo.renderPass = gpuFramebuffer->gpuRenderPass->vkRenderPass;
+ createInfo.attachmentCount = attachments.size();
+ createInfo.pAttachments = attachments.data();
+ createInfo.width = colorViewCount ? gpuFramebuffer->gpuColorViews[0]->gpuTexture->width : 1;
+ createInfo.height = colorViewCount ? gpuFramebuffer->gpuColorViews[0]->gpuTexture->height : 1;
+ createInfo.layers = 1;
+
+ VkFramebuffer framebuffer = 0;
+ VK_CHECK(vkCreateFramebuffer(device->gpuDevice()->vkDevice, &createInfo, nullptr, &framebuffer));
+}
+
+void CCVKCmdFuncDestroyFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer)
+{
+ if (gpuFramebuffer->vkFramebuffer != VK_NULL_HANDLE)
+ {
+ vkDestroyFramebuffer(device->gpuDevice()->vkDevice, gpuFramebuffer->vkFramebuffer, nullptr);
+ gpuFramebuffer->vkFramebuffer = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncCreateBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout)
+{
+ uint32_t count = gpuBindingLayout->gpuBindings.size();
+ vector::type setBindings(count);
+
+ for (uint32_t i = 0u; i < count; i++)
+ {
+ auto &binding = gpuBindingLayout->gpuBindings[i];
+ setBindings[i].binding = binding.binding;
+ setBindings[i].descriptorType = MapVkDescriptorType(binding.type);
+ setBindings[i].descriptorCount = 1;
+ setBindings[i].stageFlags = binding.type == GFXBindingType::STORAGE_BUFFER ? VK_SHADER_STAGE_VERTEX_BIT : VK_SHADER_STAGE_ALL;
+ }
+
+ VkDescriptorSetLayoutCreateInfo setCreateInfo{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
+ setCreateInfo.bindingCount = count;
+ setCreateInfo.pBindings = setBindings.data();
+
+ VK_CHECK(vkCreateDescriptorSetLayout(device->gpuDevice()->vkDevice, &setCreateInfo, nullptr, &gpuBindingLayout->vkDescriptorSetLayout));
+}
+
+void CCVKCmdFuncDestroyBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout)
+{
+ if (gpuBindingLayout->vkDescriptorSetLayout != VK_NULL_HANDLE)
+ {
+ vkDestroyDescriptorSetLayout(device->gpuDevice()->vkDevice, gpuBindingLayout->vkDescriptorSetLayout, nullptr);
+ gpuBindingLayout->vkDescriptorSetLayout = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncCreatePipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout)
+{
+ uint32_t count = gpuPipelineLayout->gpuBindingLayouts.size();
+ vector::type descriptorSetLayouts(count);
+ for (uint32_t i = 0u; i < count; i++)
+ {
+ auto layout = gpuPipelineLayout->gpuBindingLayouts[i];
+ descriptorSetLayouts[i] = layout->vkDescriptorSetLayout;
+ }
+
+ VkPipelineLayoutCreateInfo createInfo{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
+ createInfo.setLayoutCount = count;
+ createInfo.pSetLayouts = descriptorSetLayouts.data();
+
+ VK_CHECK(vkCreatePipelineLayout(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuPipelineLayout->vkPipelineLayout));
+}
+
+void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout)
+{
+ if (gpuPipelineLayout->vkPipelineLayout != VK_NULL_HANDLE)
+ {
+ vkDestroyPipelineLayout(device->gpuDevice()->vkDevice, gpuPipelineLayout->vkPipelineLayout, nullptr);
+ gpuPipelineLayout->vkPipelineLayout = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState)
+{
+ VkGraphicsPipelineCreateInfo createInfo{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
+
+ ///////////////////// Shader Stage /////////////////////
+
+ auto &stages = gpuPipelineState->gpuShader->gpuStages;
+ uint32_t stageCount = stages.size();
+ vector::type stageInfos(stageCount, { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO });
+ for (uint32_t i = 0u; i < stageCount; i++)
+ {
+ stageInfos[i].stage = VK_SHADER_TYPES[(uint)stages[i].type];
+ stageInfos[i].module = stages[i].vkShader;
+ stageInfos[i].pName = "main";
+ }
+ createInfo.stageCount = stageCount;
+ createInfo.pStages = stageInfos.data();
+
+ ///////////////////// Input State /////////////////////
+
+ auto &attributes = gpuPipelineState->inputState.attributes;
+ uint32_t attributeCount = attributes.size();
+ uint32_t bindingCount = 1;
+ for (uint32_t i = 0u; i < attributeCount; i++)
+ {
+ auto &attr = attributes[i];
+ bindingCount = std::max(bindingCount, attr.stream + 1);
+ }
+
+ vector::type bindingDescriptions(bindingCount);
+ for (uint32_t i = 0u; i < bindingCount; i++)
+ {
+ bindingDescriptions[i].binding = i;
+ bindingDescriptions[i].stride = 0;
+ bindingDescriptions[i].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+ }
+ for (uint32_t i = 0u; i < attributeCount; i++)
+ {
+ auto &attr = attributes[i];
+ bindingDescriptions[attr.stream].stride += GFX_FORMAT_INFOS[(uint)attr.format].size;
+ if (attr.isInstanced)
+ {
+ bindingDescriptions[attr.stream].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
+ }
+ }
+
+ vector::type offsets(bindingCount, 0);
+ vector::type attributeDescriptions(attributeCount);
+ for (uint32_t i = 0u; i < attributeCount; i++)
+ {
+ auto &attr = attributes[i];
+ attributeDescriptions[i].location = i;
+ attributeDescriptions[i].binding = attr.stream;
+ attributeDescriptions[i].format = MapVkFormat(attr.format);
+ attributeDescriptions[i].offset = offsets[attr.stream];
+ offsets[attr.stream] += GFX_FORMAT_INFOS[(uint)attr.format].size;
+ }
+
+ VkPipelineVertexInputStateCreateInfo vertexInput{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
+ vertexInput.vertexBindingDescriptionCount = bindingCount;
+ vertexInput.pVertexBindingDescriptions = bindingDescriptions.data();
+ vertexInput.vertexAttributeDescriptionCount = attributeCount;
+ vertexInput.pVertexAttributeDescriptions = attributeDescriptions.data();
+ createInfo.pVertexInputState = &vertexInput;
+
+ ///////////////////// Input Asembly State /////////////////////
+
+ VkPipelineInputAssemblyStateCreateInfo inputAssembly{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO };
+ inputAssembly.topology = VK_PRIMITIVE_MODES[(uint)gpuPipelineState->primitive];
+ createInfo.pInputAssemblyState = &inputAssembly;
+
+ ///////////////////// Dynamic State /////////////////////
+
+ vector::type dynamicStates{ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
+ InsertVkDynamicStates(dynamicStates, gpuPipelineState->dynamicStates);
+
+ VkPipelineDynamicStateCreateInfo dynamicState{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO };
+ dynamicState.dynamicStateCount = dynamicStates.size();
+ dynamicState.pDynamicStates = dynamicStates.data();
+ createInfo.pDynamicState = &dynamicState;
+
+ ///////////////////// Viewport State /////////////////////
+
+ VkPipelineViewportStateCreateInfo viewportState{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO };
+ viewportState.viewportCount = 1; // dynamic by default
+ viewportState.scissorCount = 1; // dynamic by default
+ createInfo.pViewportState = &viewportState;
+
+ ///////////////////// Rasterization State /////////////////////
+
+ VkPipelineRasterizationStateCreateInfo rasterizationState{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
+
+ //rasterizationState.depthClampEnable;
+ rasterizationState.rasterizerDiscardEnable = gpuPipelineState->rs.isDiscard;
+ rasterizationState.polygonMode = VK_POLYGON_MODES[(uint)gpuPipelineState->rs.polygonMode];
+ rasterizationState.cullMode = VK_CULL_MODES[(uint)gpuPipelineState->rs.cullMode];
+ rasterizationState.frontFace = gpuPipelineState->rs.isFrontFaceCCW ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE;
+ rasterizationState.depthBiasEnable = !!gpuPipelineState->rs.depthBias;
+ rasterizationState.depthBiasConstantFactor = gpuPipelineState->rs.depthBias;
+ rasterizationState.depthBiasClamp = gpuPipelineState->rs.depthBiasClamp;
+ rasterizationState.depthBiasSlopeFactor = gpuPipelineState->rs.depthBiasSlop;
+ rasterizationState.lineWidth = gpuPipelineState->rs.lineWidth;
+ createInfo.pRasterizationState = &rasterizationState;
+
+ ///////////////////// Multisample State /////////////////////
+
+ VkPipelineMultisampleStateCreateInfo multisampleState{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO };
+ multisampleState.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+ //multisampleState.sampleShadingEnable;
+ //multisampleState.minSampleShading;
+ //multisampleState.pSampleMask;
+ //multisampleState.alphaToCoverageEnable;
+ //multisampleState.alphaToOneEnable;
+ createInfo.pMultisampleState = &multisampleState;
+
+ ///////////////////// Depth Stencil State /////////////////////
+
+ VkPipelineDepthStencilStateCreateInfo depthStencilState = { VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
+ depthStencilState.depthTestEnable = gpuPipelineState->dss.depthTest;
+ depthStencilState.depthWriteEnable = gpuPipelineState->dss.depthWrite;
+ depthStencilState.depthCompareOp = VK_CMP_FUNCS[(uint)gpuPipelineState->dss.depthFunc];
+ depthStencilState.stencilTestEnable = gpuPipelineState->dss.stencilTestFront;
+ depthStencilState.front =
+ {
+ VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilFailOpFront],
+ VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilPassOpFront],
+ VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilZFailOpFront],
+ VK_CMP_FUNCS[(uint)gpuPipelineState->dss.stencilFuncFront],
+ gpuPipelineState->dss.stencilReadMaskFront,
+ gpuPipelineState->dss.stencilWriteMaskFront,
+ gpuPipelineState->dss.stencilRefFront,
+ };
+ depthStencilState.back =
+ {
+ VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilFailOpBack],
+ VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilPassOpBack],
+ VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilZFailOpBack],
+ VK_CMP_FUNCS[(uint)gpuPipelineState->dss.stencilFuncBack],
+ gpuPipelineState->dss.stencilReadMaskBack,
+ gpuPipelineState->dss.stencilWriteMaskBack,
+ gpuPipelineState->dss.stencilRefBack,
+ };
+ //depthStencilState.depthBoundsTestEnable;
+ //depthStencilState.minDepthBounds;
+ //depthStencilState.maxDepthBounds;
+ createInfo.pDepthStencilState = &depthStencilState;
+
+ ///////////////////// Blend State /////////////////////
+
+ uint32_t blendTargetCount = gpuPipelineState->bs.targets.size();
+ vector::type blendTargets(blendTargetCount);
+ for (uint32_t i = 0u; i < blendTargetCount; i++)
+ {
+ auto &target = gpuPipelineState->bs.targets[i];
+ blendTargets[i].blendEnable = target.blend;
+ blendTargets[i].srcColorBlendFactor = VK_BLEND_FACTORS[(uint)target.blendSrc];
+ blendTargets[i].dstColorBlendFactor = VK_BLEND_FACTORS[(uint)target.blendDst];
+ blendTargets[i].colorBlendOp = VK_BLEND_OPS[(uint)target.blendEq];
+ blendTargets[i].srcAlphaBlendFactor = VK_BLEND_FACTORS[(uint)target.blendSrcAlpha];
+ blendTargets[i].dstAlphaBlendFactor = VK_BLEND_FACTORS[(uint)target.blendDstAlpha];
+ blendTargets[i].alphaBlendOp = VK_BLEND_OPS[(uint)target.blendAlphaEq];
+ blendTargets[i].colorWriteMask = MapVkColorComponentFlags(target.blendColorMask);
+ }
+ auto &blendColor = gpuPipelineState->bs.blendColor;
+
+ VkPipelineColorBlendStateCreateInfo colorBlendState{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO };
+ //colorBlendState.logicOpEnable;
+ //colorBlendState.logicOp;
+ colorBlendState.attachmentCount = blendTargetCount;
+ colorBlendState.pAttachments = blendTargets.data();
+ colorBlendState.blendConstants[0] = blendColor.r;
+ colorBlendState.blendConstants[1] = blendColor.g;
+ colorBlendState.blendConstants[2] = blendColor.b;
+ colorBlendState.blendConstants[3] = blendColor.a;
+ createInfo.pColorBlendState = &colorBlendState;
+
+ ///////////////////// References /////////////////////
+
+ createInfo.layout = gpuPipelineState->gpuLayout->vkPipelineLayout;
+ createInfo.renderPass = gpuPipelineState->gpuRenderPass->vkRenderPass;
+
+ ///////////////////// Creation /////////////////////
+
+ VK_CHECK(vkCreateGraphicsPipelines(device->gpuDevice()->vkDevice, gpuPipelineState->vkPipelineCache,
+ 1, &createInfo, nullptr, &gpuPipelineState->vkPipeline));
+}
+
+void CCVKCmdFuncDestroyPipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState)
+{
+ if (gpuPipelineState->vkPipeline != VK_NULL_HANDLE)
+ {
+ vkDestroyPipeline(device->gpuDevice()->vkDevice, gpuPipelineState->vkPipeline, nullptr);
+ gpuPipelineState->vkPipeline = VK_NULL_HANDLE;
+ }
+}
+
+void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice* device, uint8_t* const* buffers, CCVKGPUTexture* gpuTexture, const GFXBufferTextureCopyList& regions)
+{
+
+}
+
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKCommands.h b/native/cocos/renderer/gfx-vulkan/VKCommands.h
new file mode 100644
index 0000000000..e63f639e2a
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKCommands.h
@@ -0,0 +1,205 @@
+#ifndef CC_GFXVULKAN_COMMANDS_H_
+#define CC_GFXVULKAN_COMMANDS_H_
+
+#include "VKGPUObjects.h"
+
+NS_CC_BEGIN
+
+class CCVKDevice;
+
+struct CCVKDepthBias
+{
+ float constant = 0.0f;
+ float clamp = 0.0f;
+ float slope = 0.0f;
+};
+
+struct CCVKDepthBounds
+{
+ float minBounds = 0.0f;
+ float maxBounds = 0.0f;
+};
+
+struct CCVKStencilWriteMask
+{
+ GFXStencilFace face = GFXStencilFace::FRONT;
+ uint32_t write_mask = 0;
+};
+
+struct CCVKStencilCompareMask
+{
+ GFXStencilFace face = GFXStencilFace::FRONT;
+ int reference = 0;
+ uint32_t compareMask = 0;
+};
+
+struct CCVKTextureSubres
+{
+ uint baseMipLevel = 0;
+ uint levelCount = 1;
+ uint baseArrayLayer = 0;
+ uint layerCount = 1;
+};
+
+struct CCVKBufferTextureCopy
+{
+ uint buffOffset = 0;
+ uint buffStride = 0;
+ uint buffTexHeight = 0;
+ uint texOffset[3] = { 0 };
+ uint texExtent[3] = { 0 };
+ CCVKTextureSubres texSubres;
+};
+
+class CCVKCmdBeginRenderPass : public GFXCmd
+{
+public:
+ CCVKGPUFramebuffer* gpuFBO = nullptr;
+ GFXRect render_area;
+ GFXClearFlags clear_flags = GFXClearFlagBit::NONE;
+ uint num_clear_colors = 0;
+ GFXColor clear_colors[GFX_MAX_ATTACHMENTS];
+ float clear_depth = 1.0f;
+ int clear_stencil = 0;
+
+ CCVKCmdBeginRenderPass() : GFXCmd(GFXCmdType::BEGIN_RENDER_PASS) {}
+
+ void clear()
+ {
+ gpuFBO = nullptr;
+ num_clear_colors = 0;
+ }
+};
+
+enum class CCVKState : uint8_t
+{
+ VIEWPORT,
+ SCISSOR,
+ LINE_WIDTH,
+ DEPTH_BIAS,
+ BLEND_CONSTANTS,
+ DEPTH_BOUNDS,
+ STENCIL_WRITE_MASK,
+ STENCIL_COMPARE_MASK,
+ COUNT,
+};
+
+class CCVKCmdBindStates : public GFXCmd
+{
+public:
+ CCVKGPUPipelineState* gpuPipelineState = nullptr;
+ CCVKGPUBindingLayout* gpuBindingLayout = nullptr;
+ CCVKGPUInputAssembler* gpuInputAssembler = nullptr;
+ uint8_t state_flags[(int)CCVKState::COUNT] = { 0 };
+ GFXViewport viewport;
+ GFXRect scissor;
+ float lineWidth = 1.0f;
+ CCVKDepthBias depthBias;
+ GFXColor blendConstants;
+ CCVKDepthBounds depthBounds;
+ CCVKStencilWriteMask stencilWriteMask;
+ CCVKStencilCompareMask stencilCompareMask;
+
+ CCVKCmdBindStates() : GFXCmd(GFXCmdType::BIND_STATES) {}
+
+ void clear()
+ {
+ gpuPipelineState = nullptr;
+ gpuBindingLayout = nullptr;
+ gpuInputAssembler = nullptr;
+ memset(state_flags, 0, sizeof(state_flags));
+ }
+};
+
+class CCVKCmdDraw : public GFXCmd
+{
+public:
+ GFXDrawInfo draw_info;
+
+ CCVKCmdDraw() : GFXCmd(GFXCmdType::DRAW) {}
+ void clear() {}
+};
+
+class CCVKCmdUpdateBuffer : public GFXCmd
+{
+public:
+ CCVKGPUBuffer* gpuBuffer = nullptr;
+ uint8_t* buffer = nullptr;
+ uint size = 0;
+ uint offset = 0;
+
+ CCVKCmdUpdateBuffer() : GFXCmd(GFXCmdType::UPDATE_BUFFER) {}
+
+ void clear()
+ {
+ gpuBuffer = nullptr;
+ buffer = nullptr;
+ }
+};
+
+class CCVKCmdCopyBufferToTexture : public GFXCmd
+{
+public:
+ CCVKGPUBuffer* gpuBuffer = nullptr;
+ CCVKGPUTexture* gpuTexture = nullptr;
+ GFXTextureLayout dst_layout;
+ GFXBufferTextureCopyList regions;
+
+ CCVKCmdCopyBufferToTexture() : GFXCmd(GFXCmdType::COPY_BUFFER_TO_TEXTURE) {}
+
+ void clear()
+ {
+ gpuBuffer = nullptr;
+ gpuTexture = nullptr;
+ regions.clear();
+ }
+};
+
+class CCVKCmdPackage : public Object
+{
+public:
+ CachedArray cmds;
+ CachedArray beginRenderPassCmds;
+ CachedArray bindStatesCmds;
+ CachedArray drawCmds;
+ CachedArray updateBufferCmds;
+ CachedArray copyBufferToTextureCmds;
+};
+
+CC_VULKAN_API void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass);
+CC_VULKAN_API void CCVKCmdFuncDestroyRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass);
+CC_VULKAN_API void CCVKCmdFuncGetDeviceQueue(CCVKDevice* device, CCVKGPUQueue* gpuQueue);
+CC_VULKAN_API void CCVKCmdFuncCreateCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool);
+CC_VULKAN_API void CCVKCmdFuncDestroyCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool);
+CC_VULKAN_API void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer);
+CC_VULKAN_API void CCVKCmdFuncFreeCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer);
+
+CC_VULKAN_API void CCVKCmdFuncCreateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer);
+CC_VULKAN_API void CCVKCmdFuncDestroyBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer);
+CC_VULKAN_API void CCVKCmdFuncResizeBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer);
+CC_VULKAN_API void CCVKCmdFuncUpdateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer, void* buffer, uint offset, uint size);
+CC_VULKAN_API void CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture);
+CC_VULKAN_API void CCVKCmdFuncDestroyTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture);
+CC_VULKAN_API void CCVKCmdFuncCreateTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView);
+CC_VULKAN_API void CCVKCmdFuncDestroyTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView);
+CC_VULKAN_API void CCVKCmdFuncResizeTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture);
+CC_VULKAN_API void CCVKCmdFuncCreateSampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler);
+CC_VULKAN_API void CCVKCmdFuncDestroySampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler);
+CC_VULKAN_API void CCVKCmdFuncCreateShader(CCVKDevice* device, CCVKGPUShader* gpuShader);
+CC_VULKAN_API void CCVKCmdFuncDestroyShader(CCVKDevice* device, CCVKGPUShader* gpuShader);
+CC_VULKAN_API void CCVKCmdFuncCreateInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler);
+CC_VULKAN_API void CCVKCmdFuncDestroyInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler);
+CC_VULKAN_API void CCVKCmdFuncCreateFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer);
+CC_VULKAN_API void CCVKCmdFuncDestroyFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer);
+CC_VULKAN_API void CCVKCmdFuncCreateBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout);
+CC_VULKAN_API void CCVKCmdFuncDestroyBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout);
+CC_VULKAN_API void CCVKCmdFuncCreatePipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout);
+CC_VULKAN_API void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout);
+CC_VULKAN_API void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState);
+CC_VULKAN_API void CCVKCmdFuncDestroyPipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState);
+
+CC_VULKAN_API void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice* device, uint8_t* const* buffers, CCVKGPUTexture* gpuTexture, const GFXBufferTextureCopyList& regions);
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKContext.cc b/native/cocos/renderer/gfx-vulkan/VKContext.cc
new file mode 100644
index 0000000000..1c864c1610
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKContext.cc
@@ -0,0 +1,532 @@
+#include "VKStd.h"
+#include "VKContext.h"
+#include "VKUtils.h"
+#include "VKGPUObjects.h"
+#include "VKDevice.h"
+#include "VKRenderPass.h"
+#include "VKTexture.h"
+#include "VKTextureView.h"
+
+#define WIN32_LEAN_AND_MEAN
+#include "windows.h"
+
+#define CC_GFX_DEBUG
+
+NS_CC_BEGIN
+
+namespace
+{
+#ifdef CC_GFX_DEBUG
+ VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT *callbackData, void * user_data)
+ {
+ // Log debug messge
+ if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
+ {
+ CC_LOG_WARNING("%s: %s", callbackData->pMessageIdName, callbackData->pMessage);
+ }
+ else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
+ {
+ CC_LOG_ERROR("%s: %s", callbackData->pMessageIdName, callbackData->pMessage);
+ assert(false);
+ }
+ return VK_FALSE;
+ }
+
+ VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT type,
+ uint64_t object, size_t location, int32_t messageCode, const char *layerPrefix, const char *message, void *userData)
+ {
+ if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
+ {
+ CC_LOG_ERROR("VError: %s: %s", layerPrefix, message);
+ assert(false);
+ }
+ else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT)
+ {
+ CC_LOG_ERROR("VWarning: %s: %s", layerPrefix, message);
+ }
+ else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT)
+ {
+ CC_LOG_INFO("VPerfWarning: %s: %s", layerPrefix, message);
+ }
+ else
+ {
+ CC_LOG_INFO("VInfo: %s: %s", layerPrefix, message);
+ }
+ return VK_FALSE;
+ }
+#endif
+}
+
+CCVKContext::CCVKContext(GFXDevice* device)
+ : GFXContext(device){
+}
+
+CCVKContext::~CCVKContext() {
+}
+
+bool CCVKContext::initialize(const GFXContextInfo &info) {
+
+ _vsyncMode = info.vsyncMode;
+ _windowHandle = info.windowHandle;
+
+ if (!info.sharedCtx)
+ {
+ _isPrimaryContex = true;
+ _windowHandle = info.windowHandle;
+
+ _gpuContext = CC_NEW(CCVKGPUContext);
+
+ // only enable the absolute essentials for now
+ std::vector requestedLayers
+ {
+
+ };
+ std::vector requestedExtensions
+ {
+ VK_KHR_SURFACE_EXTENSION_NAME,
+ };
+
+ ///////////////////// Instance Creation /////////////////////
+
+ if (volkInitialize())
+ {
+ return false;
+ }
+
+ uint32_t availableLayerCount;
+ VK_CHECK(vkEnumerateInstanceLayerProperties(&availableLayerCount, nullptr));
+ std::vector supportedLayers(availableLayerCount);
+ VK_CHECK(vkEnumerateInstanceLayerProperties(&availableLayerCount, supportedLayers.data()));
+
+ uint32_t availableExtensionCount;
+ VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &availableExtensionCount, nullptr));
+ std::vector supportedExtensions(availableExtensionCount);
+ VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &availableExtensionCount, supportedExtensions.data()));
+
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+ requestedExtensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
+#elif defined(VK_USE_PLATFORM_WIN32_KHR)
+ requestedExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
+#elif defined(VK_USE_PLATFORM_IOS_MVK)
+ requestedExtensions.push_back(VK_MVK_IOS_SURFACE_EXTENSION_NAME);
+#elif defined(VK_USE_PLATFORM_MACOS_MVK)
+ requestedExtensions.push_back(VK_MVK_MACOS_SURFACE_EXTENSION_NAME);
+#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
+ requestedExtensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+ requestedExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
+#else
+# pragma error Platform not supported
+#endif
+
+#ifdef CC_GFX_DEBUG
+ // Determine the optimal validation layers to enable that are necessary for useful debugging
+ std::vector> validationLayerPriorityList
+ {
+ // The preferred validation layer is "VK_LAYER_KHRONOS_validation"
+ {"VK_LAYER_KHRONOS_validation"},
+
+ // Otherwise we fallback to using the LunarG meta layer
+ {"VK_LAYER_LUNARG_standard_validation"},
+
+ // Otherwise we attempt to enable the individual layers that compose the LunarG meta layer since it doesn't exist
+ {
+ "VK_LAYER_GOOGLE_threading",
+ "VK_LAYER_LUNARG_parameter_validation",
+ "VK_LAYER_LUNARG_object_tracker",
+ "VK_LAYER_LUNARG_core_validation",
+ "VK_LAYER_GOOGLE_unique_objects",
+ },
+
+ // Otherwise as a last resort we fallback to attempting to enable the LunarG core layer
+ {"VK_LAYER_LUNARG_core_validation"}
+ };
+ for (auto &validationLayers : validationLayerPriorityList)
+ {
+ bool found = true;
+ for (auto &layer : validationLayers)
+ {
+ if (!isLayerSupported(layer, supportedLayers))
+ {
+ found = false;
+ break;
+ }
+ }
+ if (found)
+ {
+ requestedLayers.insert(requestedLayers.end(), validationLayers.begin(), validationLayers.end());
+ break;
+ }
+ }
+
+ // Check if VK_EXT_debug_utils is supported, which supersedes VK_EXT_Debug_Report
+ bool debugUtils = false;
+ if (isExtensionSupported(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, supportedExtensions))
+ {
+ debugUtils = true;
+ requestedExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+ }
+ else
+ {
+ requestedExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+ }
+#endif
+
+ // just filter out the unsupported layers & extensions
+ for (auto &layer : requestedLayers)
+ {
+ if (isLayerSupported(layer, supportedLayers))
+ {
+ _layers.push_back(layer);
+ }
+ }
+ for (auto &extension : requestedExtensions)
+ {
+ if (isExtensionSupported(extension, supportedExtensions))
+ {
+ _extensions.push_back(extension);
+ }
+ }
+
+ uint32_t apiVersion;
+ vkEnumerateInstanceVersion(&apiVersion);
+
+ VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
+ app.pEngineName = "Cocos Creator";
+ app.apiVersion = apiVersion;
+
+ VkInstanceCreateInfo instanceInfo{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
+ instanceInfo.pApplicationInfo = &app;
+ instanceInfo.enabledExtensionCount = toU32(_extensions.size());
+ instanceInfo.ppEnabledExtensionNames = _extensions.data();
+ instanceInfo.enabledLayerCount = toU32(_layers.size());
+ instanceInfo.ppEnabledLayerNames = _layers.data();
+
+#ifdef CC_GFX_DEBUG
+ VkDebugUtilsMessengerCreateInfoEXT debugUtilsCreateInfo{ VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT };
+ VkDebugReportCallbackCreateInfoEXT debugReportCreateInfo{ VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT };
+ if (debugUtils)
+ {
+ debugUtilsCreateInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
+ debugUtilsCreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
+ debugUtilsCreateInfo.pfnUserCallback = debugUtilsMessengerCallback;
+
+ instanceInfo.pNext = &debugUtilsCreateInfo;
+ }
+ else
+ {
+ debugReportCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
+ debugReportCreateInfo.pfnCallback = debugReportCallback;
+
+ instanceInfo.pNext = &debugReportCreateInfo;
+ }
+#endif
+
+ // Create the Vulkan instance
+ VK_CHECK(vkCreateInstance(&instanceInfo, nullptr, &_gpuContext->vkInstance));
+
+ volkLoadInstance(_gpuContext->vkInstance);
+
+#ifdef CC_GFX_DEBUG
+ if (debugUtils)
+ {
+ VK_CHECK(vkCreateDebugUtilsMessengerEXT(_gpuContext->vkInstance, &debugUtilsCreateInfo, nullptr, &_gpuContext->vkDebugUtilsMessenger));
+ }
+ else
+ {
+ VK_CHECK(vkCreateDebugReportCallbackEXT(_gpuContext->vkInstance, &debugReportCreateInfo, nullptr, &_gpuContext->vkDebugReport));
+ }
+#endif
+
+ _majorVersion = VK_VERSION_MAJOR(apiVersion);
+ _minorVersion = VK_VERSION_MINOR(apiVersion);
+
+ ///////////////////// Surface Creation /////////////////////
+
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+ VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR };
+ surfaceCreateInfo.window = (ANativeWindow*)_windowHandle;
+ VK_CHECK(vkCreateAndroidSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
+#elif defined(VK_USE_PLATFORM_WIN32_KHR)
+ VkWin32SurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR };
+ surfaceCreateInfo.hinstance = (HINSTANCE)GetModuleHandle(0);
+ surfaceCreateInfo.hwnd = (HWND)_windowHandle;
+ VK_CHECK(vkCreateWin32SurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
+#elif defined(VK_USE_PLATFORM_IOS_MVK)
+ VkIOSSurfaceCreateInfoMVK surfaceCreateInfo{ VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK };
+ surfaceCreateInfo.pView = (void*)_windowHandle;
+ VK_CHECK(vkCreateIOSSurfaceMVK(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
+#elif defined(VK_USE_PLATFORM_MACOS_MVK)
+ VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo{ VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK };
+ surfaceCreateInfo.pView = (void*)_windowHandle;
+ VK_CHECK(vkCreateMacOSSurfaceMVK(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
+#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
+ VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR };
+ surfaceCreateInfo.display = nullptr; // TODO
+ surfaceCreateInfo.surface = (wl_surface*)_windowHandle;
+ VK_CHECK(vkCreateWaylandSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+ VkXcbSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR };
+ surfaceCreateInfo.connection = nullptr; // TODO
+ surfaceCreateInfo.window = (xcb_window_t)_windowHandle;
+ VK_CHECK(vkCreateXcbSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
+#else
+# pragma error Platform not supported
+#endif
+
+ ///////////////////// Physical Device Selection /////////////////////
+
+ // Querying valid physical devices on the machine
+ uint32_t physicalDeviceCount{ 0 };
+ VK_CHECK(vkEnumeratePhysicalDevices(_gpuContext->vkInstance, &physicalDeviceCount, nullptr));
+
+ if (physicalDeviceCount < 1)
+ {
+ return false;
+ }
+
+ std::vector physicalDeviceHandles(physicalDeviceCount);
+ VK_CHECK(vkEnumeratePhysicalDevices(_gpuContext->vkInstance, &physicalDeviceCount, physicalDeviceHandles.data()));
+
+ std::vector physicalDeviceProperties(physicalDeviceCount);
+
+ uint32_t deviceIndex;
+ for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex)
+ {
+ VkPhysicalDeviceProperties& properties = physicalDeviceProperties[deviceIndex];
+ vkGetPhysicalDeviceProperties(physicalDeviceHandles[deviceIndex], &properties);
+ }
+
+ for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex)
+ {
+ VkPhysicalDeviceProperties& properties = physicalDeviceProperties[deviceIndex];
+ if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+ {
+ break;
+ }
+ }
+
+ _gpuContext->physicalDevice = physicalDeviceHandles[deviceIndex];
+ _gpuContext->physicalDeviceProperties = physicalDeviceProperties[deviceIndex];
+ vkGetPhysicalDeviceFeatures(_gpuContext->physicalDevice, &_gpuContext->physicalDeviceFeatures);
+ vkGetPhysicalDeviceMemoryProperties(_gpuContext->physicalDevice, &_gpuContext->physicalDeviceMemoryProperties);
+ uint32_t queueFamilyPropertiesCount = 0;
+ vkGetPhysicalDeviceQueueFamilyProperties(_gpuContext->physicalDevice, &queueFamilyPropertiesCount, nullptr);
+ _gpuContext->queueFamilyProperties.resize(queueFamilyPropertiesCount);
+ vkGetPhysicalDeviceQueueFamilyProperties(_gpuContext->physicalDevice, &queueFamilyPropertiesCount, _gpuContext->queueFamilyProperties.data());
+ _gpuContext->queueFamilyPresentables.resize(queueFamilyPropertiesCount);
+ for (uint32_t propertyIndex = 0U; propertyIndex < queueFamilyPropertiesCount; propertyIndex++)
+ {
+ vkGetPhysicalDeviceSurfaceSupportKHR(_gpuContext->physicalDevice, propertyIndex,
+ _gpuContext->vkSurface, &_gpuContext->queueFamilyPresentables[propertyIndex]);
+ }
+
+ ///////////////////// Swapchain Preperation /////////////////////
+
+ _colorFmt = GFXFormat::BGRA8;
+ _depthStencilFmt = GFXFormat::D24S8;
+
+ VkSurfaceCapabilitiesKHR surfaceCapabilities{};
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &surfaceCapabilities);
+
+ uint32_t surfaceFormatCount = 0u;
+ VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &surfaceFormatCount, nullptr));
+ std::vector surfaceFormats(surfaceFormatCount);
+ VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &surfaceFormatCount, surfaceFormats.data()));
+
+ uint32_t presentModeCount = 0u;
+ VK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &presentModeCount, nullptr));
+ std::vector presentModes(presentModeCount);
+ VK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &presentModeCount, presentModes.data()));
+
+ VkExtent2D imageExtent{ surfaceCapabilities.currentExtent.width, surfaceCapabilities.currentExtent.height };
+
+ VkFormat colorFormat = VK_FORMAT_B8G8R8A8_UNORM;
+ VkColorSpaceKHR colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+ // If the surface format list only includes one entry with VK_FORMAT_UNDEFINED,
+ // there is no preferered format, so we assume VK_FORMAT_B8G8R8A8_UNORM
+ if ((surfaceFormatCount == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED))
+ {
+ colorFormat = VK_FORMAT_B8G8R8A8_UNORM;
+ colorSpace = surfaceFormats[0].colorSpace;
+ }
+ else
+ {
+ // iterate over the list of available surface format and
+ // check for the presence of VK_FORMAT_B8G8R8A8_UNORM
+ bool imageFormatFound = false;
+ for (auto&& surfaceFormat : surfaceFormats)
+ {
+ if (surfaceFormat.format == VK_FORMAT_B8G8R8A8_UNORM)
+ {
+ colorFormat = surfaceFormat.format;
+ colorSpace = surfaceFormat.colorSpace;
+ imageFormatFound = true;
+ break;
+ }
+ }
+
+ // in case VK_FORMAT_B8G8R8A8_UNORM is not available
+ // select the first available color format
+ if (!imageFormatFound)
+ {
+ colorFormat = surfaceFormats[0].format;
+ colorSpace = surfaceFormats[0].colorSpace;
+ }
+ }
+
+ std::vector> depthFormatPriorityList =
+ {
+ { GFXFormat::D32F_S8, VK_FORMAT_D32_SFLOAT_S8_UINT },
+ { GFXFormat::D24S8, VK_FORMAT_D24_UNORM_S8_UINT },
+ { GFXFormat::D16S8, VK_FORMAT_D16_UNORM_S8_UINT },
+ { GFXFormat::D32F, VK_FORMAT_D32_SFLOAT },
+ { GFXFormat::D16, VK_FORMAT_D16_UNORM }
+ };
+ for (auto& format : depthFormatPriorityList)
+ {
+ VkFormatProperties formatProperties;
+ vkGetPhysicalDeviceFormatProperties(_gpuContext->physicalDevice, format.second, &formatProperties);
+ // Format must support depth stencil attachment for optimal tiling
+ if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
+ {
+ if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
+ {
+ _depthStencilFmt = format.first;
+ break;
+ }
+ }
+ }
+
+ // Select a present mode for the swapchain
+
+ std::vector presentModePriorityList;
+
+ switch (_vsyncMode)
+ {
+ case GFXVsyncMode::OFF: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR }); break;
+ case GFXVsyncMode::ON: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_KHR }); break;
+ case GFXVsyncMode::RELAXED: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_FIFO_KHR }); break;
+ case GFXVsyncMode::MAILBOX: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR }); break;
+ case GFXVsyncMode::HALF: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_KHR }); break; // TODO
+ }
+
+ VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+
+ for (auto &presentMode : presentModePriorityList)
+ {
+ if (std::find(presentModes.begin(), presentModes.end(), presentMode) != presentModes.end())
+ {
+ swapchainPresentMode = presentMode;
+ }
+ }
+
+ // Determine the number of images
+ uint32_t desiredNumberOfSwapchainImages = surfaceCapabilities.minImageCount + 1;
+ if ((surfaceCapabilities.maxImageCount > 0) && (desiredNumberOfSwapchainImages > surfaceCapabilities.maxImageCount))
+ {
+ desiredNumberOfSwapchainImages = surfaceCapabilities.maxImageCount;
+ }
+
+ // Find the transformation of the surface
+ VkSurfaceTransformFlagBitsKHR preTransform;
+ if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR)
+ {
+ // We prefer a non-rotated transform
+ preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+ }
+ else
+ {
+ preTransform = surfaceCapabilities.currentTransform;
+ }
+
+ // Find a supported composite alpha format (not all devices support alpha opaque)
+ VkCompositeAlphaFlagBitsKHR compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+ // Simply select the first composite alpha format available
+ std::vector compositeAlphaFlags = {
+ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
+ VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
+ VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
+ };
+ for (auto& compositeAlphaFlag : compositeAlphaFlags)
+ {
+ if (surfaceCapabilities.supportedCompositeAlpha & compositeAlphaFlag)
+ {
+ compositeAlpha = compositeAlphaFlag;
+ break;
+ };
+ }
+ VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+ // Enable transfer source on swap chain images if supported
+ if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
+ {
+ imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+ }
+
+ // Enable transfer destination on swap chain images if supported
+ if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
+ {
+ imageUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+ }
+
+ _gpuContext->swapchainCreateInfo.surface = _gpuContext->vkSurface;
+ _gpuContext->swapchainCreateInfo.minImageCount = desiredNumberOfSwapchainImages;
+ _gpuContext->swapchainCreateInfo.imageFormat = colorFormat;
+ _gpuContext->swapchainCreateInfo.imageColorSpace = colorSpace;
+ _gpuContext->swapchainCreateInfo.imageExtent = imageExtent;
+ _gpuContext->swapchainCreateInfo.imageUsage = imageUsage;
+ _gpuContext->swapchainCreateInfo.imageArrayLayers = 1;
+ _gpuContext->swapchainCreateInfo.preTransform = preTransform;
+ _gpuContext->swapchainCreateInfo.compositeAlpha = compositeAlpha;
+ _gpuContext->swapchainCreateInfo.presentMode = swapchainPresentMode;
+ _gpuContext->swapchainCreateInfo.clipped = VK_TRUE; // Setting clipped to VK_TRUE allows the implementation to discard rendering outside of the surface area
+
+ } else {
+ CCVKContext* sharedCtx = (CCVKContext*)info.sharedCtx;
+
+ _majorVersion = sharedCtx->majorVersion();
+ _minorVersion = sharedCtx->minorVersion();
+
+ // TODO
+ }
+
+ return true;
+}
+
+void CCVKContext::destroy()
+{
+ if (_gpuContext)
+ {
+ if (_gpuContext->vkSurface != VK_NULL_HANDLE)
+ {
+ vkDestroySurfaceKHR(_gpuContext->vkInstance, _gpuContext->vkSurface, nullptr);
+ _gpuContext->vkSurface = VK_NULL_HANDLE;
+ }
+
+#ifdef CC_GFX_DEBUG
+ if (_gpuContext->vkDebugUtilsMessenger != VK_NULL_HANDLE)
+ {
+ vkDestroyDebugUtilsMessengerEXT(_gpuContext->vkInstance, _gpuContext->vkDebugUtilsMessenger, nullptr);
+ _gpuContext->vkDebugUtilsMessenger = VK_NULL_HANDLE;
+ }
+ if (_gpuContext->vkDebugReport != VK_NULL_HANDLE)
+ {
+ vkDestroyDebugReportCallbackEXT(_gpuContext->vkInstance, _gpuContext->vkDebugReport, nullptr);
+ _gpuContext->vkDebugReport = VK_NULL_HANDLE;
+ }
+#endif
+
+ if (_gpuContext->vkInstance != VK_NULL_HANDLE)
+ {
+ vkDestroyInstance(_gpuContext->vkInstance, nullptr);
+ _gpuContext->vkInstance = VK_NULL_HANDLE;
+ }
+
+ CC_DELETE(_gpuContext);
+ _gpuContext = nullptr;
+ }
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKContext.h b/native/cocos/renderer/gfx-vulkan/VKContext.h
new file mode 100644
index 0000000000..34598009ba
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKContext.h
@@ -0,0 +1,48 @@
+#ifndef CC_GFXVULKAN_CCVK_CONTEXT_H_
+#define CC_GFXVULKAN_CCVK_CONTEXT_H_
+
+NS_CC_BEGIN
+
+class CCVKDevice;
+class CCVKGPUDevice;
+class CCVKGPUContext;
+class CCVKGPUSwapchain;
+class CCVKGPUSemaphorePool;
+
+class CC_VULKAN_API CCVKContext : public GFXContext {
+public:
+ CCVKContext(GFXDevice* device);
+ ~CCVKContext();
+
+public:
+ bool initialize(const GFXContextInfo& info);
+ void destroy();
+ void present() {}
+
+ CC_INLINE bool checkExtension(const String& extension) const
+ {
+ return std::find_if(_extensions.begin(), _extensions.end(),
+ [extension](auto &device_extension)
+ {
+ return std::strcmp(device_extension, extension.c_str()) == 0;
+ }) != _extensions.end();
+ }
+
+ CC_INLINE int majorVersion() const { return _majorVersion; }
+ CC_INLINE int minorVersion() const { return _minorVersion; }
+ CC_INLINE CCVKGPUContext* gpuContext() { return _gpuContext; }
+ CC_INLINE const std::vector& getLayers() const { return _layers; }
+ CC_INLINE const std::vector& getExtensions() const { return _extensions; }
+
+private:
+ CCVKGPUContext* _gpuContext = nullptr;
+ bool _isPrimaryContex = false;
+ int _majorVersion = 0;
+ int _minorVersion = 0;
+ std::vector _layers;
+ std::vector _extensions;
+};
+
+NS_CC_END
+
+#endif // CC_GFXVULKAN_CCVK_CONTEXT_H_
diff --git a/native/cocos/renderer/gfx-vulkan/VKContext.mm b/native/cocos/renderer/gfx-vulkan/VKContext.mm
new file mode 100644
index 0000000000..691fbf280a
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKContext.mm
@@ -0,0 +1,198 @@
+#include "VKStd.h"
+#include "VKContext.h"
+#include "gles3w.h"
+#import
+#import
+
+NS_CC_BEGIN
+
+#if (CC_PLATFORM == CC_PLATFORM_MAC_IOS)
+
+bool VKContext::initialize(const GFXContextInfo &info)
+{
+
+ _vsyncMode = info.vsyncMode;
+ _windowHandle = info.windowHandle;
+
+ //////////////////////////////////////////////////////////////////////////
+
+ if (!info.sharedCtx)
+ {
+ _isPrimaryContex = true;
+ _windowHandle = info.windowHandle;
+
+ CAEAGLLayer* eaglLayer = (CAEAGLLayer*)( ((UIView*)(_windowHandle)).layer);
+ eaglLayer.opaque = TRUE;
+
+ EAGLContext* eagl_context = [[EAGLContext alloc]initWithAPI:kEAGLRenderingAPIOpenVK];
+ if (!eagl_context)
+ {
+ CC_LOG_ERROR("Create EAGL context failed.");
+ return false;
+ }
+
+ _eaglContext = (intptr_t)eagl_context;
+ _eaglSharedContext = (intptr_t)eagl_context;
+
+ if (!VKwInit())
+ {
+ return false;
+ }
+ }
+ else
+ {
+ VKContext* sharedCtx = (VKContext*)info.sharedCtx;
+ EAGLContext* eagl_shared_context = (EAGLContext*)sharedCtx->eagl_shared_ctx();
+ EAGLContext* eagl_context = [[EAGLContext alloc] initWithAPI: [eagl_shared_context API] sharegroup: [eagl_shared_context sharegroup]];
+ if (!eagl_context)
+ {
+ CC_LOG_ERROR("Create EGL context with share context [0x%p] failed.", eagl_shared_context);
+
+ _eaglContext = (intptr_t)eagl_context;
+ _eaglSharedContext = (intptr_t)eagl_shared_context;
+
+ return false;
+ }
+ }
+ _colorFmt = GFXFormat::RGBA8;
+ _depthStencilFmt = GFXFormat::D24S8;
+
+ if (!MakeCurrent())
+ return false;
+
+ return createCustomFrameBuffer();
+}
+
+bool VKContext::createCustomFrameBuffer()
+{
+ glGenFramebuffers(1, &_defaultFBO);
+ if (0 == _defaultFBO)
+ {
+ CC_LOG_ERROR("Can not create default frame buffer");
+ return false;
+ }
+ glBindFramebuffer(GL_FRAMEBUFFER, _defaultFBO);
+
+ glGenRenderbuffers(1, &_defaultColorBuffer);
+ if (0 == _defaultColorBuffer)
+ {
+ CC_LOG_ERROR("Can not create default color buffer");
+ return false;
+ }
+ glBindRenderbuffer(GL_RENDERBUFFER, _defaultColorBuffer);
+
+ CAEAGLLayer* eaglLayer = (CAEAGLLayer*)( ((UIView*)(_windowHandle)).layer);
+ if (! [(EAGLContext*)_eaglContext renderbufferStorage:GL_RENDERBUFFER
+ fromDrawable:eaglLayer])
+ {
+ CC_LOG_ERROR("Attaches EAGLDrawable as storage for the OpenGL ES renderbuffer object failed.");
+ glBindRenderbuffer(GL_RENDERBUFFER, 0);
+ glDeleteRenderbuffers(1, &_defaultColorBuffer);
+ return false;
+ }
+
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, _defaultColorBuffer);
+
+ GLint framebufferWidth = 0, framebufferHeight = 0;
+ glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &framebufferWidth);
+ glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &framebufferHeight);
+
+ glGenRenderbuffers(1, &_defaultDepthStencilBuffer);
+ if (_defaultDepthStencilBuffer == 0)
+ {
+ // Application can run without depth/stencil buffer, so don't return false here.
+ CC_LOG_ERROR("Can not create default depth/stencil buffer");
+ }
+
+ glBindRenderbuffer(GL_RENDERBUFFER, _defaultDepthStencilBuffer);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, framebufferWidth, framebufferHeight);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, _defaultDepthStencilBuffer);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, _defaultDepthStencilBuffer);
+
+ GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+ if (status != GL_FRAMEBUFFER_COMPLETE)
+ {
+ switch (status)
+ {
+ case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+ {
+ CC_LOG_ERROR("glCheckFramebufferStatus() - FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
+ break;
+ }
+ case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+ {
+ CC_LOG_ERROR("glCheckFramebufferStatus() - FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
+ break;
+ }
+ case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+ {
+ CC_LOG_ERROR("glCheckFramebufferStatus() - FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
+ break;
+ }
+ case GL_FRAMEBUFFER_UNSUPPORTED:
+ {
+ CC_LOG_ERROR("glCheckFramebufferStatus() - FRAMEBUFFER_UNSUPPORTED");
+ break;
+ }
+ default:;
+ }
+ destroyCustomFrameBuffer();
+ return false;
+ }
+
+ glBindRenderbuffer(GL_RENDERBUFFER, _defaultColorBuffer);
+ return true;
+}
+
+void VKContext::destroyCustomFrameBuffer()
+{
+ if (_defaultColorBuffer)
+ {
+ glDeleteRenderbuffers(1, &_defaultColorBuffer);
+ _defaultColorBuffer = 0;
+ }
+ if (_defaultDepthStencilBuffer)
+ {
+ glDeleteRenderbuffers(1, &_defaultDepthStencilBuffer);
+ _defaultDepthStencilBuffer = 0;
+ }
+
+ if (_defaultFBO)
+ {
+ glDeleteFramebuffers(1, &_defaultFBO);
+ _defaultFBO = 0;
+ }
+}
+
+void VKContext::destroy()
+{
+ destroyCustomFrameBuffer();
+
+ if (_eaglContext)
+ {
+ [(EAGLContext*)_eaglContext release];
+ }
+
+ _isPrimaryContex = false;
+ _windowHandle = 0;
+ _vsyncMode = GFXVsyncMode::OFF;
+ _isInitialized = false;
+}
+
+void VKContext::present()
+{
+
+ if (! [(EAGLContext*)_eaglContext presentRenderbuffer:GL_RENDERBUFFER] )
+ {
+ CC_LOG_ERROR("Failed to present content.");
+ }
+}
+
+bool VKContext::MakeCurrentImpl()
+{
+ return [EAGLContext setCurrentContext:(EAGLContext*)_eaglContext];
+}
+
+#endif
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.cc b/native/cocos/renderer/gfx-vulkan/VKDevice.cc
new file mode 100644
index 0000000000..830eab044a
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKDevice.cc
@@ -0,0 +1,592 @@
+#include "VKStd.h"
+#include "VKDevice.h"
+#include "VKUtils.h"
+#include "VKStateCache.h"
+#include "VKContext.h"
+#include "VKWindow.h"
+#include "VKQueue.h"
+#include "VKCommandAllocator.h"
+#include "VKCommandBuffer.h"
+#include "VKBuffer.h"
+#include "VKTexture.h"
+#include "VKTextureView.h"
+#include "VKSampler.h"
+#include "VKShader.h"
+#include "VKInputAssembler.h"
+#include "VKRenderPass.h"
+#include "VKFramebuffer.h"
+#include "VKBindingLayout.h"
+#include "VKPipelineLayout.h"
+#include "VKPipelineState.h"
+
+NS_CC_BEGIN
+
+CCVKDevice::CCVKDevice()
+{
+}
+
+CCVKDevice::~CCVKDevice()
+{
+}
+
+bool CCVKDevice::initialize(const GFXDeviceInfo& info)
+{
+ _gfxAPI = GFXAPI::VULKAN;
+ _deviceName = "Vulkan";
+ _width = info.width;
+ _height = info.height;
+ _nativeWidth = info.nativeWidth;
+ _nativeHeight = info.nativeHeight;
+ _windowHandle = info.windowHandle;
+
+ stateCache = CC_NEW(CCVKStateCache);
+
+ GFXContextInfo contextCreateInfo;
+ contextCreateInfo.windowHandle = _windowHandle;
+ contextCreateInfo.sharedCtx = info.sharedCtx;
+
+ _context = CC_NEW(CCVKContext(this));
+ if (!_context->initialize(contextCreateInfo))
+ {
+ destroy();
+ return false;
+ }
+ auto context = ((CCVKContext*)_context)->gpuContext();
+ auto &deviceFeatures = context->physicalDeviceFeatures;
+
+ // only enable the absolute essentials for now
+ std::vector requestedValidationLayers
+ {
+
+ };
+ std::vector requestedExtensions
+ {
+ VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+ };
+ VkPhysicalDeviceFeatures requestedFeatures{};
+ // features should be enabled like this
+ requestedFeatures.textureCompressionASTC_LDR = deviceFeatures.textureCompressionASTC_LDR;
+ requestedFeatures.textureCompressionBC = deviceFeatures.textureCompressionBC;
+ requestedFeatures.textureCompressionETC2 = deviceFeatures.textureCompressionETC2;
+
+ ///////////////////// Device Creation /////////////////////
+
+ _gpuDevice = CC_NEW(CCVKGPUDevice);
+ _gpuSemaphorePool = CC_NEW(CCVKGPUSemaphorePool(_gpuDevice));
+
+ // check extensions
+ uint32_t availableLayerCount;
+ VK_CHECK(vkEnumerateDeviceLayerProperties(context->physicalDevice, &availableLayerCount, nullptr));
+ _gpuDevice->layers.resize(availableLayerCount);
+ VK_CHECK(vkEnumerateDeviceLayerProperties(context->physicalDevice, &availableLayerCount, _gpuDevice->layers.data()));
+
+ uint32_t availableExtensionCount;
+ VK_CHECK(vkEnumerateDeviceExtensionProperties(context->physicalDevice, nullptr, &availableExtensionCount, nullptr));
+ _gpuDevice->extensions.resize(availableExtensionCount);
+ VK_CHECK(vkEnumerateDeviceExtensionProperties(context->physicalDevice, nullptr, &availableExtensionCount, _gpuDevice->extensions.data()));
+
+ // just filter out the unsupported layers & extensions
+ for (auto &layer : requestedValidationLayers)
+ {
+ if (isLayerSupported(layer, _gpuDevice->layers))
+ {
+ _layers.push_back(layer);
+ }
+ }
+ for (auto &extension : requestedExtensions)
+ {
+ if (isExtensionSupported(extension, _gpuDevice->extensions))
+ {
+ _extensions.push_back(extension);
+ }
+ }
+
+ // prepare the device queues
+ uint32_t queueFamilyPropertiesCount = toU32(context->queueFamilyProperties.size());
+ std::vector queueCreateInfos(queueFamilyPropertiesCount, { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO });
+ std::vector> queuePriorities(queueFamilyPropertiesCount);
+
+ for (uint32_t queueFamilyIndex = 0u; queueFamilyIndex < queueFamilyPropertiesCount; ++queueFamilyIndex)
+ {
+ const VkQueueFamilyProperties &queueFamilyProperty = context->queueFamilyProperties[queueFamilyIndex];
+
+ queuePriorities[queueFamilyIndex].resize(queueFamilyProperty.queueCount, 1.0f);
+
+ VkDeviceQueueCreateInfo &queueCreateInfo = queueCreateInfos[queueFamilyIndex];
+
+ queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
+ queueCreateInfo.queueCount = queueFamilyProperty.queueCount;
+ queueCreateInfo.pQueuePriorities = queuePriorities[queueFamilyIndex].data();
+ }
+
+ VkDeviceCreateInfo deviceCreateInfo{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+
+ deviceCreateInfo.queueCreateInfoCount = toU32(queueCreateInfos.size());
+ deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
+ deviceCreateInfo.enabledLayerCount = toU32(_layers.size());
+ deviceCreateInfo.ppEnabledLayerNames = _layers.data();
+ deviceCreateInfo.enabledExtensionCount = toU32(_extensions.size());
+ deviceCreateInfo.ppEnabledExtensionNames = _extensions.data();
+ deviceCreateInfo.pEnabledFeatures = &requestedFeatures;
+ deviceCreateInfo.pNext = nullptr;
+
+ VK_CHECK(vkCreateDevice(context->physicalDevice, &deviceCreateInfo, nullptr, &_gpuDevice->vkDevice));
+
+ ///////////////////// Resource Initialization /////////////////////
+
+ for (uint32_t i = 0; i < context->swapchainCreateInfo.minImageCount; i++)
+ {
+ GFXTextureInfo depthStecnilTexInfo;
+ depthStecnilTexInfo.type = GFXTextureType::TEX2D;
+ depthStecnilTexInfo.usage = GFXTextureUsageBit::DEPTH_STENCIL_ATTACHMENT | GFXTextureUsageBit::SAMPLED;
+ depthStecnilTexInfo.format = _context->getDepthStencilFormat();
+ depthStecnilTexInfo.width = 1;
+ depthStecnilTexInfo.height = 1;
+ auto texture = (CCVKTexture*)createTexture(depthStecnilTexInfo);
+ _depthStencilTextures.push_back(texture);
+
+ GFXTextureViewInfo depthStecnilTexViewInfo;
+ depthStecnilTexViewInfo.texture = texture;
+ depthStecnilTexViewInfo.type = GFXTextureViewType::TV2D;
+ depthStecnilTexViewInfo.format = _context->getDepthStencilFormat();
+ auto textureView = (CCVKTextureView*)createTextureView(depthStecnilTexViewInfo);
+ _depthStencilTextureViews.push_back(textureView);
+ }
+
+ GFXRenderPassInfo renderPassInfo;
+ GFXColorAttachment colorAttachment;
+ colorAttachment.format = _context->getColorFormat();
+ colorAttachment.loadOp = GFXLoadOp::CLEAR;
+ colorAttachment.storeOp = GFXStoreOp::STORE;
+ colorAttachment.sampleCount = 1;
+ colorAttachment.beginLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL;
+ colorAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
+ renderPassInfo.colorAttachments.emplace_back(colorAttachment);
+
+ GFXDepthStencilAttachment& depthStencilAttachment = renderPassInfo.depthStencilAttachment;
+ depthStencilAttachment.format = _context->getDepthStencilFormat();
+ depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR;
+ depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE;
+ depthStencilAttachment.stencilLoadOp = GFXLoadOp::CLEAR;
+ depthStencilAttachment.stencilStoreOp = GFXStoreOp::STORE;
+ depthStencilAttachment.sampleCount = 1;
+ depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+ depthStencilAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
+
+ _renderPass = (CCVKRenderPass*)createRenderPass(renderPassInfo);
+ _gpuSwapchain = CC_NEW(CCVKGPUSwapchain);
+ _gpuSwapchain->renderPass = _renderPass->gpuRenderPass();
+
+ buildSwapchain();
+
+ GFXWindowInfo windowInfo;
+ windowInfo.colorFmt = _context->getColorFormat();
+ windowInfo.depthStencilFmt = _context->getDepthStencilFormat();
+ windowInfo.isOffscreen = false;
+ _window = createWindow(windowInfo);
+
+ GFXQueueInfo queueInfo;
+ queueInfo.type = GFXQueueType::GRAPHICS;
+ _queue = createQueue(queueInfo);
+
+ GFXCommandAllocatorInfo cmd_alloc_info;
+ _cmdAllocator = createCommandAllocator(cmd_alloc_info);
+
+ String instanceLayers, instanceExtensions, deviceLayers, deviceExtensions;
+ for (auto layer : ((CCVKContext*)_context)->getLayers())
+ {
+ instanceLayers += layer + String(" ");
+ }
+ for (auto extension : ((CCVKContext*)_context)->getExtensions())
+ {
+ instanceExtensions += extension + String(" ");
+ }
+ for (auto layer : _layers)
+ {
+ deviceLayers += layer + String(" ");
+ }
+ for (auto extension : _extensions)
+ {
+ deviceExtensions += extension + String(" ");
+ }
+
+ String compressedFmts;
+ if (deviceFeatures.textureCompressionETC2)
+ {
+ _features[(int)GFXFeature::FORMAT_ETC2] = true;
+ compressedFmts += "etc2 ";
+ }
+ if (deviceFeatures.textureCompressionASTC_LDR)
+ {
+ _features[(int)GFXFeature::FORMAT_ASTC] = true;
+ compressedFmts += "astc ";
+ }
+
+ CC_LOG_INFO("Vulkan device initialized.");
+ CC_LOG_INFO("DEVICE_NAME: %s", context->physicalDeviceProperties.deviceName);
+ CC_LOG_INFO("VULKAN_VERSION: %d.%d", ((CCVKContext*)_context)->majorVersion(), ((CCVKContext*)_context)->minorVersion());
+ CC_LOG_INFO("SCREEN_SIZE: %d x %d", _width, _height);
+ CC_LOG_INFO("NATIVE_SIZE: %d x %d", _nativeWidth, _nativeHeight);
+ CC_LOG_INFO("INSTANCE_LAYERS: %s", instanceLayers.c_str());
+ CC_LOG_INFO("INSTANCE_EXTENSIONS: %s", instanceExtensions.c_str());
+ CC_LOG_INFO("DEVICE_LAYERS: %s", deviceLayers.c_str());
+ CC_LOG_INFO("DEVICE_EXTENSIONS: %s", deviceExtensions.c_str());
+ CC_LOG_INFO("COMPRESSED_FORMATS: %s", compressedFmts.c_str());
+
+ this->begin();
+
+ return true;
+}
+
+void CCVKDevice::destroy()
+{
+ CC_SAFE_DESTROY(_cmdAllocator);
+ CC_SAFE_DESTROY(_queue);
+ CC_SAFE_DESTROY(_window);
+ CC_SAFE_DESTROY(_renderPass);
+ CC_SAFE_DELETE(_gpuSemaphorePool);
+
+ for (auto textureView : _depthStencilTextureViews)
+ {
+ CC_SAFE_DESTROY(textureView);
+ }
+ for (auto texture : _depthStencilTextures)
+ {
+ CC_SAFE_DESTROY(texture);
+ }
+
+ if (_gpuSwapchain)
+ {
+ if (_gpuSwapchain->vkSwapchain != VK_NULL_HANDLE)
+ {
+ _gpuSwapchain->depthStencilImageViews.clear();
+ _gpuSwapchain->depthStencilImages.clear();
+
+ for (auto framebuffer : _gpuSwapchain->vkSwapchainFramebuffers)
+ {
+ vkDestroyFramebuffer(_gpuDevice->vkDevice, framebuffer, nullptr);
+ }
+ _gpuSwapchain->vkSwapchainFramebuffers.clear();
+
+ for (auto imageView : _gpuSwapchain->vkSwapchainImageViews)
+ {
+ vkDestroyImageView(_gpuDevice->vkDevice, imageView, nullptr);
+ }
+ _gpuSwapchain->vkSwapchainImageViews.clear();
+ _gpuSwapchain->swapchainImages.clear();
+
+ vkDestroySwapchainKHR(_gpuDevice->vkDevice, _gpuSwapchain->vkSwapchain, nullptr);
+ _gpuSwapchain->vkSwapchain = VK_NULL_HANDLE;
+ }
+
+ CC_DELETE(_gpuSwapchain);
+ _gpuSwapchain = nullptr;
+ }
+
+ if (_gpuDevice)
+ {
+ if (_gpuDevice->vkDevice != VK_NULL_HANDLE)
+ {
+ vkDestroyDevice(_gpuDevice->vkDevice, nullptr);
+ _gpuDevice->vkDevice = VK_NULL_HANDLE;
+ }
+
+ CC_DELETE(_gpuDevice);
+ _gpuDevice = nullptr;
+ }
+
+ CC_SAFE_DESTROY(_context);
+}
+
+void CCVKDevice::resize(uint width, uint height)
+{
+ _width = width;
+ _height = height;
+ buildSwapchain();
+ _window->resize(_width, _height);
+}
+
+void CCVKDevice::buildSwapchain()
+{
+ auto context = ((CCVKContext*)_context)->gpuContext();
+ context->swapchainCreateInfo.oldSwapchain = _gpuSwapchain->vkSwapchain;
+
+ VkSurfaceCapabilitiesKHR surfaceCapabilities;
+ VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(context->physicalDevice, context->vkSurface, &surfaceCapabilities));
+ if (surfaceCapabilities.currentExtent.width == (uint32_t)-1)
+ {
+ context->swapchainCreateInfo.imageExtent.width = _width;
+ context->swapchainCreateInfo.imageExtent.height = _height;
+ }
+ else
+ {
+ _width = context->swapchainCreateInfo.imageExtent.width = surfaceCapabilities.currentExtent.width;
+ _height = context->swapchainCreateInfo.imageExtent.height = surfaceCapabilities.currentExtent.height;
+ }
+ VK_CHECK(vkCreateSwapchainKHR(_gpuDevice->vkDevice, &context->swapchainCreateInfo, nullptr, &_gpuSwapchain->vkSwapchain));
+
+ if (context->swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE)
+ {
+ _gpuSwapchain->depthStencilImageViews.clear();
+ _gpuSwapchain->depthStencilImages.clear();
+
+ for (auto framebuffer : _gpuSwapchain->vkSwapchainFramebuffers)
+ {
+ vkDestroyFramebuffer(_gpuDevice->vkDevice, framebuffer, nullptr);
+ }
+ _gpuSwapchain->vkSwapchainFramebuffers.clear();
+
+ for (auto imageView : _gpuSwapchain->vkSwapchainImageViews)
+ {
+ vkDestroyImageView(_gpuDevice->vkDevice, imageView, nullptr);
+ }
+ _gpuSwapchain->vkSwapchainImageViews.clear();
+ _gpuSwapchain->swapchainImages.clear();
+
+ vkDestroySwapchainKHR(_gpuDevice->vkDevice, context->swapchainCreateInfo.oldSwapchain, nullptr);
+ }
+
+ uint32_t imageCount;
+ VK_CHECK(vkGetSwapchainImagesKHR(_gpuDevice->vkDevice, _gpuSwapchain->vkSwapchain, &imageCount, nullptr));
+ _gpuSwapchain->swapchainImages.resize(imageCount);
+ VK_CHECK(vkGetSwapchainImagesKHR(_gpuDevice->vkDevice, _gpuSwapchain->vkSwapchain, &imageCount, _gpuSwapchain->swapchainImages.data()));
+ assert(imageCount == context->swapchainCreateInfo.minImageCount); // assert if swapchain image count assumption is broken
+
+ _gpuSwapchain->vkSwapchainImageViews.resize(imageCount);
+ _gpuSwapchain->vkSwapchainFramebuffers.resize(imageCount);
+ for (uint32_t i = 0; i < imageCount; i++)
+ {
+ _depthStencilTextures[i]->resize(_width, _height);
+ _gpuSwapchain->depthStencilImages.push_back(((CCVKTexture*)_depthStencilTextures[i])->gpuTexture()->vkImage);
+
+ _depthStencilTextureViews[i]->destroy();
+ GFXTextureViewInfo textureViewInfo;
+ textureViewInfo.texture = _depthStencilTextures[i];
+ textureViewInfo.type = GFXTextureViewType::TV2D;
+ textureViewInfo.format = _context->getDepthStencilFormat();
+ _depthStencilTextureViews[i]->initialize(textureViewInfo);
+ _gpuSwapchain->depthStencilImageViews.push_back(((CCVKTextureView*)_depthStencilTextureViews[i])->gpuTexView()->vkImageView);
+
+ VkImageViewCreateInfo imageViewCreateInfo{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ imageViewCreateInfo.image = _gpuSwapchain->swapchainImages[i];
+ imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+ imageViewCreateInfo.format = context->swapchainCreateInfo.imageFormat;
+ imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ imageViewCreateInfo.subresourceRange.levelCount = 1;
+ imageViewCreateInfo.subresourceRange.layerCount = 1;
+
+ VK_CHECK(vkCreateImageView(_gpuDevice->vkDevice, &imageViewCreateInfo, nullptr, &_gpuSwapchain->vkSwapchainImageViews[i]));
+
+ VkImageView attachments[] = { _gpuSwapchain->vkSwapchainImageViews[i], _depthStencilTextureViews[i]->gpuTexView()->vkImageView };
+
+ VkFramebufferCreateInfo framebufferCreateInfo{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+ framebufferCreateInfo.renderPass = _renderPass->gpuRenderPass()->vkRenderPass;
+ framebufferCreateInfo.attachmentCount = COUNTOF(attachments);
+ framebufferCreateInfo.pAttachments = attachments;
+ framebufferCreateInfo.width = _width;
+ framebufferCreateInfo.height = _height;
+ framebufferCreateInfo.layers = 1;
+
+ VK_CHECK(vkCreateFramebuffer(_gpuDevice->vkDevice, &framebufferCreateInfo, 0, &_gpuSwapchain->vkSwapchainFramebuffers[i]));
+ }
+}
+
+void CCVKDevice::begin()
+{
+ CCVKGPUQueue* queue = ((CCVKQueue*)_queue)->gpuQueue();
+
+ _gpuSemaphorePool->clear();
+ VkSemaphore acquireSemaphore = _gpuSemaphorePool->alloc();
+ VK_CHECK(vkAcquireNextImageKHR(_gpuDevice->vkDevice, _gpuSwapchain->vkSwapchain,
+ ~0ull, acquireSemaphore, VK_NULL_HANDLE, &_gpuSwapchain->curImageIndex));
+ VK_CHECK(vkResetCommandPool(_gpuDevice->vkDevice, ((CCVKCommandAllocator*)_cmdAllocator)->gpuCommandPool()->vkCommandPool, 0));
+
+ queue->waitSemaphore = acquireSemaphore;
+ queue->signalSemaphore = _gpuSemaphorePool->alloc();
+}
+
+void CCVKDevice::present()
+{
+ //((CCVKCommandAllocator*)_cmdAllocator)->releaseCmds();
+ CCVKQueue* queue = (CCVKQueue*)_queue;
+ _numDrawCalls = queue->_numDrawCalls;
+ _numInstances = queue->_numInstances;
+ _numTriangles = queue->_numTriangles;
+
+ VkPresentInfoKHR presentInfo{ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
+ presentInfo.waitSemaphoreCount = 1;
+ presentInfo.pWaitSemaphores = &queue->gpuQueue()->waitSemaphore;
+ presentInfo.swapchainCount = 1;
+ presentInfo.pSwapchains = &_gpuSwapchain->vkSwapchain;
+ presentInfo.pImageIndices = &_gpuSwapchain->curImageIndex;
+
+ VK_CHECK(vkQueuePresentKHR(queue->gpuQueue()->vkQueue, &presentInfo));
+
+ VK_CHECK(vkDeviceWaitIdle(_gpuDevice->vkDevice));
+
+ // Clear queue stats
+ queue->_numDrawCalls = 0;
+ queue->_numInstances = 0;
+ queue->_numTriangles = 0;
+
+ this->begin();
+}
+
+GFXWindow* CCVKDevice::createWindow(const GFXWindowInfo& info)
+{
+ GFXWindow* window = CC_NEW(CCVKWindow(this));
+ if (window->initialize(info))
+ return window;
+
+ CC_SAFE_DESTROY(window);
+ return nullptr;
+}
+
+GFXQueue* CCVKDevice::createQueue(const GFXQueueInfo& info)
+{
+ GFXQueue* queue = CC_NEW(CCVKQueue(this));
+ if (queue->initialize(info))
+ return queue;
+
+ CC_SAFE_DESTROY(queue);
+ return nullptr;
+}
+
+GFXCommandAllocator* CCVKDevice::createCommandAllocator(const GFXCommandAllocatorInfo& info)
+{
+ GFXCommandAllocator* cmdAllocator = CC_NEW(CCVKCommandAllocator(this));
+ if (cmdAllocator->initialize(info))
+ return cmdAllocator;
+
+ CC_SAFE_DESTROY(cmdAllocator);
+ return nullptr;
+}
+
+GFXCommandBuffer* CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo& info)
+{
+ GFXCommandBuffer* gfx_cmd_buff = CC_NEW(CCVKCommandBuffer(this));
+ if (gfx_cmd_buff->initialize(info))
+ return gfx_cmd_buff;
+
+ CC_SAFE_DESTROY(gfx_cmd_buff)
+ return nullptr;
+}
+
+GFXBuffer* CCVKDevice::createBuffer(const GFXBufferInfo& info)
+{
+ GFXBuffer* buffer = CC_NEW(CCVKBuffer(this));
+ if (buffer->initialize(info))
+ return buffer;
+
+ CC_SAFE_DESTROY(buffer);
+ return nullptr;
+}
+
+GFXTexture* CCVKDevice::createTexture(const GFXTextureInfo& info)
+{
+ GFXTexture* texture = CC_NEW(CCVKTexture(this));
+ if (texture->initialize(info))
+ return texture;
+
+ CC_SAFE_DESTROY(texture);
+ return nullptr;
+}
+
+GFXTextureView* CCVKDevice::createTextureView(const GFXTextureViewInfo& info)
+{
+ GFXTextureView* texView = CC_NEW(CCVKTextureView(this));
+ if (texView->initialize(info))
+ return texView;
+
+ CC_SAFE_DESTROY(texView);
+ return nullptr;
+}
+
+GFXSampler* CCVKDevice::createSampler(const GFXSamplerInfo& info)
+{
+ GFXSampler* sampler = CC_NEW(CCVKSampler(this));
+ if (sampler->initialize(info))
+ return sampler;
+
+ CC_SAFE_DESTROY(sampler);
+ return nullptr;
+}
+
+GFXShader* CCVKDevice::createShader(const GFXShaderInfo& info)
+{
+ GFXShader* shader = CC_NEW(CCVKShader(this));
+ if (shader->initialize(info))
+ return shader;
+
+ CC_SAFE_DESTROY(shader);
+ return nullptr;
+}
+
+GFXInputAssembler* CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo& info)
+{
+ GFXInputAssembler* inputAssembler = CC_NEW(CCVKInputAssembler(this));
+ if (inputAssembler->initialize(info))
+ return inputAssembler;
+
+ CC_SAFE_DESTROY(inputAssembler);
+ return nullptr;
+}
+
+GFXRenderPass* CCVKDevice::createRenderPass(const GFXRenderPassInfo& info)
+{
+ GFXRenderPass* renderPass = CC_NEW(CCVKRenderPass(this));
+ if (renderPass->initialize(info))
+ return renderPass;
+
+ CC_SAFE_DESTROY(renderPass);
+ return nullptr;
+}
+
+GFXFramebuffer* CCVKDevice::createFramebuffer(const GFXFramebufferInfo& info)
+{
+ GFXFramebuffer* framebuffer = CC_NEW(CCVKFramebuffer(this));
+ if (framebuffer->initialize(info))
+ return framebuffer;
+
+ CC_SAFE_DESTROY(framebuffer);
+ return nullptr;
+}
+
+GFXBindingLayout* CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo& info)
+{
+ GFXBindingLayout* bindingLayout = CC_NEW(CCVKBindingLayout(this));
+ if (bindingLayout->initialize(info))
+ return bindingLayout;
+
+ CC_SAFE_DESTROY(bindingLayout);
+ return nullptr;
+}
+
+
+GFXPipelineState* CCVKDevice::createPipelineState(const GFXPipelineStateInfo& info)
+{
+ GFXPipelineState* pipelineState = CC_NEW(CCVKPipelineState(this));
+ if (pipelineState->initialize(info))
+ return pipelineState;
+
+ CC_SAFE_DESTROY(pipelineState);
+ return nullptr;
+}
+
+GFXPipelineLayout* CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo& info)
+{
+ GFXPipelineLayout* layout = CC_NEW(CCVKPipelineLayout(this));
+ if (layout->initialize(info))
+ return layout;
+
+ CC_SAFE_DESTROY(layout);
+ return nullptr;
+}
+
+void CCVKDevice::copyBuffersToTexture(const GFXDataArray& buffers, GFXTexture* dst, const GFXBufferTextureCopyList& regions)
+{
+
+ CCVKCmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((CCVKTexture*)dst)->gpuTexture(), regions);
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.h b/native/cocos/renderer/gfx-vulkan/VKDevice.h
new file mode 100644
index 0000000000..73056636de
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKDevice.h
@@ -0,0 +1,74 @@
+#ifndef CC_GFXVULKAN_CCVK_DEVICE_H_
+#define CC_GFXVULKAN_CCVK_DEVICE_H_
+
+NS_CC_BEGIN
+
+class CCVKStateCache;
+class CCVKGPUDevice;
+class CCVKGPUSwapchain;
+class CCVKGPUSemaphorePool;
+class CCVKTexture;
+class CCVKTextureView;
+class CCVKRenderPass;;
+
+class CC_VULKAN_API CCVKDevice : public GFXDevice
+{
+public:
+ CCVKDevice();
+ ~CCVKDevice();
+
+ CCVKStateCache* stateCache = nullptr;
+
+public:
+ bool initialize(const GFXDeviceInfo& info) override;
+ void destroy() override;
+ void resize(uint width, uint height) override;
+ void begin() override;
+ void present() override;
+ GFXWindow* createWindow(const GFXWindowInfo& info) override;
+ GFXQueue* createQueue(const GFXQueueInfo& info) override;
+ GFXCommandAllocator* createCommandAllocator(const GFXCommandAllocatorInfo& info) override;
+ GFXCommandBuffer* createCommandBuffer(const GFXCommandBufferInfo& info) override;
+ GFXBuffer* createBuffer(const GFXBufferInfo& info) override;
+ GFXTexture* createTexture(const GFXTextureInfo& info) override;
+ GFXTextureView* createTextureView(const GFXTextureViewInfo& info) override;
+ GFXSampler* createSampler(const GFXSamplerInfo& info) override;
+ GFXShader* createShader(const GFXShaderInfo& info) override;
+ GFXInputAssembler* createInputAssembler(const GFXInputAssemblerInfo& info) override;
+ GFXRenderPass* createRenderPass(const GFXRenderPassInfo& info) override;
+ GFXFramebuffer* createFramebuffer(const GFXFramebufferInfo& info) override;
+ GFXBindingLayout* createBindingLayout(const GFXBindingLayoutInfo& info) override;
+ virtual GFXPipelineState* createPipelineState(const GFXPipelineStateInfo& info) override;
+ virtual GFXPipelineLayout* createPipelineLayout(const GFXPipelineLayoutInfo& info) override;
+ virtual void copyBuffersToTexture(const GFXDataArray& buffers, GFXTexture* dst, const GFXBufferTextureCopyList& regions) override;
+
+ CC_INLINE bool checkExtension(const String& extension) const {
+ return std::find_if(_extensions.begin(), _extensions.end(),
+ [extension](auto &device_extension) {
+ return std::strcmp(device_extension, extension.c_str()) == 0;
+ }) != _extensions.end();
+ }
+
+ CC_INLINE CCVKGPUDevice* gpuDevice() const { return _gpuDevice; }
+ CC_INLINE CCVKGPUSwapchain* gpuSwapchain() { return _gpuSwapchain; }
+ CC_INLINE CCVKGPUSemaphorePool* gpuSemaphorePool() { return _gpuSemaphorePool; }
+ CC_INLINE const std::vector& getLayers() const { return _layers; }
+ CC_INLINE const std::vector& getExtensions() const { return _extensions; }
+
+private:
+ void buildSwapchain();
+
+ CCVKGPUDevice* _gpuDevice = nullptr;
+ CCVKGPUSemaphorePool* _gpuSemaphorePool = nullptr;
+ CCVKGPUSwapchain* _gpuSwapchain = nullptr;
+ std::vector _depthStencilTextureViews;
+ std::vector _depthStencilTextures;
+ CCVKRenderPass* _renderPass;
+
+ std::vector _layers;
+ std::vector _extensions;
+};
+
+NS_CC_END
+
+#endif // CC_GFXVULKAN_CCVK_DEVICE_H_
diff --git a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc
new file mode 100644
index 0000000000..a86d32f07d
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc
@@ -0,0 +1,69 @@
+#include "VKStd.h"
+#include "VKFramebuffer.h"
+#include "VKRenderPass.h"
+#include "VKCommands.h"
+#include "VKTextureView.h"
+#include "VKDevice.h"
+
+NS_CC_BEGIN
+
+CCVKFramebuffer::CCVKFramebuffer(GFXDevice* device)
+ : GFXFramebuffer(device)
+{
+}
+
+CCVKFramebuffer::~CCVKFramebuffer()
+{
+}
+
+bool CCVKFramebuffer::initialize(const GFXFramebufferInfo &info)
+{
+ _renderPass = info.renderPass;
+ _colorViews = info.colorViews;
+ _depthStencilView = info.depthStencilView;
+ _isOffscreen = info.isOffscreen;
+
+ _gpuFBO = CC_NEW(CCVKGPUFramebuffer);
+ _gpuFBO->gpuRenderPass = ((CCVKRenderPass*)_renderPass)->gpuRenderPass();
+
+ if (_isOffscreen)
+ {
+ _gpuFBO->gpuColorViews.resize(_colorViews.size());
+ for (size_t i = 0; i < _colorViews.size(); ++i)
+ {
+ CCVKTextureView* colorview = (CCVKTextureView*)_colorViews[i];
+ _gpuFBO->gpuColorViews[i] = colorview->gpuTexView();
+ }
+
+ if (_depthStencilView)
+ {
+ _gpuFBO->gpuDepthStencilView = ((CCVKTextureView*)_depthStencilView)->gpuTexView();
+ }
+
+ _gpuFBO->isOffscreen = _isOffscreen;
+
+ }
+
+ CCVKCmdFuncCreateFramebuffer((CCVKDevice*)_device, _gpuFBO);
+
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKFramebuffer::destroy()
+{
+ if (_gpuFBO)
+ {
+ if (_isOffscreen)
+ {
+ CCVKCmdFuncDestroyFramebuffer((CCVKDevice*)_device, _gpuFBO);
+ }
+ CC_DELETE(_gpuFBO);
+ _gpuFBO = nullptr;
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h
new file mode 100644
index 0000000000..b6569c29de
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h
@@ -0,0 +1,25 @@
+#ifndef CC_GFXVULKAN_CCVK_FRAMEBUFFER_H_
+#define CC_GFXVULKAN_CCVK_FRAMEBUFFER_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUFramebuffer;
+
+class CC_VULKAN_API CCVKFramebuffer : public GFXFramebuffer {
+ public:
+ CCVKFramebuffer(GFXDevice* device);
+ ~CCVKFramebuffer();
+
+ public:
+ bool initialize(const GFXFramebufferInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUFramebuffer* gpuFBO() const { return _gpuFBO; }
+
+ private:
+ CCVKGPUFramebuffer* _gpuFBO = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h
new file mode 100644
index 0000000000..59c79a9ff1
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h
@@ -0,0 +1,371 @@
+#ifndef CC_GFXVULKAN_GPU_OBJECTS_H_
+#define CC_GFXVULKAN_GPU_OBJECTS_H_
+
+#include "volk.h"
+
+NS_CC_BEGIN
+
+class CCVKGPUContext
+{
+public:
+ VkInstance vkInstance = VK_NULL_HANDLE;
+ VkDebugUtilsMessengerEXT vkDebugUtilsMessenger = VK_NULL_HANDLE;
+ VkDebugReportCallbackEXT vkDebugReport = VK_NULL_HANDLE;
+
+ VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
+ VkPhysicalDeviceFeatures physicalDeviceFeatures{};
+ VkPhysicalDeviceProperties physicalDeviceProperties{};
+ VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties{};
+ vector::type queueFamilyProperties;
+ vector::type queueFamilyPresentables;
+
+ VkSurfaceKHR vkSurface = VK_NULL_HANDLE;
+
+ VkSwapchainCreateInfoKHR swapchainCreateInfo{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
+};
+
+class CCVKGPUDevice : public Object
+{
+public:
+ VkDevice vkDevice = VK_NULL_HANDLE;
+ vector::type layers;
+ vector::type extensions;
+};
+
+class CCVKGPURenderPass : public Object
+{
+public:
+ GFXColorAttachmentList colorAttachments;
+ GFXDepthStencilAttachment depthStencilAttachment;
+ GFXSubPassList subPasses;
+ VkRenderPass vkRenderPass;
+ vector::type clearValues;
+ vector::type beginBarriers;
+ vector::type endBarriers;
+};
+
+class CCVKGPUSwapchain
+{
+public:
+ uint32_t curImageIndex;
+ VkSwapchainKHR vkSwapchain = VK_NULL_HANDLE;
+ vector::type vkSwapchainImageViews;
+ vector::type vkSwapchainFramebuffers;
+ // external references
+ vector::type swapchainImages;
+ vector::type depthStencilImages;
+ vector::type depthStencilImageViews;
+ CCVKGPURenderPass* renderPass;
+};
+
+class CCVKGPUCommandPool : public Object
+{
+public:
+ VkCommandPool vkCommandPool = VK_NULL_HANDLE;
+ map>::type commandBuffers;
+};
+
+class CCVKGPUCommandBuffer : public Object
+{
+public:
+ GFXCommandBufferType type;
+ CCVKGPUCommandPool* commandPool = nullptr;
+ VkCommandBuffer vkCommandBuffer = VK_NULL_HANDLE;
+};
+
+class CCVKGPUQueue : public Object
+{
+public:
+ GFXQueueType type;
+ VkQueue vkQueue;
+ uint32_t queueFamilyIndex;
+ VkSemaphore waitSemaphore = VK_NULL_HANDLE;
+ VkSemaphore signalSemaphore = VK_NULL_HANDLE;
+ VkPipelineStageFlags submitStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+ CachedArray commandBuffers;
+};
+
+class CCVKGPUBuffer : public Object
+{
+public:
+ GFXBufferUsage usage = GFXBufferUsage::NONE;
+ GFXMemoryUsage memUsage = GFXMemoryUsage::NONE;
+ uint size = 0;
+ uint stride = 0;
+ uint count = 0;
+ VkBuffer vkBuffer = VK_NULL_HANDLE;
+ VkDeviceMemory vkDeviceMemory = VK_NULL_HANDLE;
+ void* buffer = nullptr;
+ GFXDrawInfoList indirects;
+};
+typedef vector::type CCVKGPUBufferList;
+
+class CCVKGPUTexture : public Object
+{
+public:
+ GFXTextureType type = GFXTextureType::TEX2D;
+ GFXTextureViewType viewType = GFXTextureViewType::TV2D;
+ GFXFormat format = GFXFormat::UNKNOWN;
+ GFXTextureUsage usage = GFXTextureUsageBit::NONE;
+ uint width = 0;
+ uint height = 0;
+ uint depth = 1;
+ uint size = 0;
+ uint arrayLayer = 1;
+ uint mipLevel = 1;
+ GFXSampleCount samples = GFXSampleCount::X1;
+ GFXTextureFlags flags = GFXTextureFlagBit::NONE;
+ bool isPowerOf2 = false;
+ VkImage vkImage = VK_NULL_HANDLE;
+ VkDeviceMemory vkDeviceMemory = VK_NULL_HANDLE;
+ //GLenum glTarget = 0;
+ //GLenum glInternelFmt = 0;
+ //GLenum glFormat = 0;
+ //GLenum glType = 0;
+ //GLenum glUsage = 0;
+ //GLuint glTexture = 0;
+ //GLenum glWrapS = 0;
+ //GLenum glWrapT = 0;
+ //GLenum glMinFilter = 0;
+ //GLenum glMagFilter = 0;
+};
+
+class CCVKGPUTextureView : public Object
+{
+public:
+ CCVKGPUTexture* gpuTexture = nullptr;
+ GFXTextureViewType type = GFXTextureViewType::TV2D;
+ GFXFormat format = GFXFormat::UNKNOWN;
+ uint baseLevel = 0;
+ uint levelCount = 1;
+ VkImageView vkImageView = VK_NULL_HANDLE;
+};
+
+typedef vector::type CCVKGPUTextureViewList;
+
+class CCVKGPUSampler : public Object {
+ public:
+ GFXFilter minFilter = GFXFilter::NONE;
+ GFXFilter magFilter = GFXFilter::NONE;
+ GFXFilter mipFilter = GFXFilter::NONE;
+ GFXAddress addressU = GFXAddress::CLAMP;
+ GFXAddress addressV = GFXAddress::CLAMP;
+ GFXAddress addressW = GFXAddress::CLAMP;
+ uint minLOD = 0;
+ uint maxLOD = 1000;
+ //GLuint gl_sampler = 0;
+ //GLenum glMinFilter = 0;
+ //GLenum glMagFilter = 0;
+ //GLenum glWrapS = 0;
+ //GLenum glWrapT = 0;
+ //GLenum glWrapR = 0;
+};
+
+struct CCVKGPUInput
+{
+ uint binding = 0;
+ String name;
+ GFXType type = GFXType::UNKNOWN;
+ uint stride = 0;
+ uint count = 0;
+ uint size = 0;
+ //GLenum glType = 0;
+ //GLint glLoc = -1;
+};
+typedef vector::type CCVKGPUInputList;
+
+struct CCVKGPUUniform
+{
+ uint binding = GFX_INVALID_BINDING;
+ String name;
+ GFXType type = GFXType::UNKNOWN;
+ uint stride = 0;
+ uint count = 0;
+ uint size = 0;
+ uint offset = 0;
+ //GLenum glType = 0;
+ //GLint glLoc = -1;
+};
+typedef vector::type CCVKGPUUniformList;
+
+struct CCVKGPUUniformBlock
+{
+ uint binding = 0;
+ uint idx = 0;
+ String name;
+ uint size = 0;
+ CCVKGPUUniformList glUniforms;
+ CCVKGPUUniformList glActiveUniforms;
+};
+typedef vector::type CCVKGPUUniformBlockList;
+
+struct CCVKGPUUniformSampler
+{
+ uint binding = 0;
+ String name;
+ GFXType type = GFXType::UNKNOWN;
+ vector::type units;
+ //GLenum glType = 0;
+ //GLint glLoc = -1;
+};
+typedef vector::type CCVKGPUUniformSamplerList;
+
+struct CCVKGPUShaderStage
+{
+ CCVKGPUShaderStage(GFXShaderType t, String s, GFXShaderMacroList m)
+ : type(t)
+ , source(s)
+ , macros(m)
+ {
+ }
+ GFXShaderType type;
+ String source;
+ GFXShaderMacroList macros;
+ VkShaderModule vkShader = VK_NULL_HANDLE;
+};
+typedef vector::type CCVKGPUShaderStageList;
+
+class CCVKGPUShader : public Object
+{
+public:
+ String name;
+ GFXUniformBlockList blocks;
+ GFXUniformSamplerList samplers;
+ CCVKGPUShaderStageList gpuStages;
+ CCVKGPUInputList gpuInputs;
+ CCVKGPUUniformBlockList gpuBlocks;
+ CCVKGPUUniformSamplerList gpuSamplers;
+};
+
+struct CCVKGPUAttribute
+{
+ String name;
+ //GLuint glBuffer = 0;
+ //GLenum glType = 0;
+ uint size = 0;
+ uint count = 0;
+ uint stride = 1;
+ uint componentCount = 1;
+ bool isNormalized = false;
+ bool isInstanced = false;
+ uint offset = 0;
+};
+typedef vector::type CCVKGPUAttributeList;
+
+class CCVKGPUInputAssembler : public Object
+{
+public:
+ GFXAttributeList attributes;
+ CCVKGPUBufferList gpuVertexBuffers;
+ CCVKGPUBuffer* gpuIndexBuffer = nullptr;
+ CCVKGPUBuffer* gpuIndirectBuffer = nullptr;
+ vector::type vertexBuffers;
+ vector::type vertexBufferOffsets;
+};
+
+class CCVKGPUFramebuffer : public Object
+{
+public:
+ CCVKGPURenderPass* gpuRenderPass = nullptr;
+ CCVKGPUTextureViewList gpuColorViews;
+ CCVKGPUTextureView* gpuDepthStencilView = nullptr;
+ VkFramebuffer vkFramebuffer = VK_NULL_HANDLE;
+ bool isOffscreen = false;
+ CCVKGPUSwapchain* swapchain = nullptr;
+};
+
+struct CCVKGPUBinding
+{
+ uint binding = GFX_INVALID_BINDING;
+ GFXBindingType type = GFXBindingType::UNKNOWN;
+ String name;
+ CCVKGPUBuffer* gpuBuffer = nullptr;
+ CCVKGPUTextureView* gpuTexView = nullptr;
+ CCVKGPUSampler* gpuSampler = nullptr;
+};
+typedef vector::type CCVKGPUBindingList;
+
+class CCVKGPUBindingLayout : public Object
+{
+public:
+ CCVKGPUBindingList gpuBindings;
+ VkDescriptorSetLayout vkDescriptorSetLayout;
+};
+
+class CCVKGPUPipelineLayout : public Object
+{
+public:
+ GFXPushConstantRangeList pushConstantRanges;
+ vector::type gpuBindingLayouts;
+ VkPipelineLayout vkPipelineLayout;
+};
+
+class CCVKGPUPipelineState : public Object
+{
+public:
+ GFXPrimitiveMode primitive = GFXPrimitiveMode::TRIANGLE_LIST;
+ CCVKGPUShader* gpuShader = nullptr;
+ GFXInputState inputState;
+ GFXRasterizerState rs;
+ GFXDepthStencilState dss;
+ GFXBlendState bs;
+ GFXDynamicStateList dynamicStates;
+ CCVKGPUPipelineLayout* gpuLayout = nullptr;
+ CCVKGPURenderPass* gpuRenderPass = nullptr;
+ VkPipeline vkPipeline = VK_NULL_HANDLE;
+ VkPipelineCache vkPipelineCache = VK_NULL_HANDLE;
+};
+
+class CCVKGPUSemaphorePool
+{
+public:
+ CCVKGPUSemaphorePool(CCVKGPUDevice* device)
+ : _device(device)
+ {
+ }
+
+ ~CCVKGPUSemaphorePool()
+ {
+ for (auto semaphore : _semaphores)
+ {
+ vkDestroySemaphore(_device->vkDevice, semaphore, nullptr);
+ }
+ _semaphores.clear();
+ _count = 0;
+ }
+
+ VkSemaphore alloc()
+ {
+ if (_count < _semaphores.size())
+ {
+ return _semaphores[_count++];
+ }
+
+ VkSemaphore semaphore = VK_NULL_HANDLE;
+ VkSemaphoreCreateInfo createInfo{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
+ VK_CHECK(vkCreateSemaphore(_device->vkDevice, &createInfo, nullptr, &semaphore));
+ _semaphores.push_back(semaphore);
+ _count++;
+
+ return semaphore;
+ }
+
+ void clear()
+ {
+ _count = 0;
+ }
+
+ uint size()
+ {
+ return _count;
+ }
+
+private:
+ CCVKGPUDevice* _device;
+ uint _count = 0;
+ vector::type _semaphores;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc
new file mode 100644
index 0000000000..19061c5d3a
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc
@@ -0,0 +1,71 @@
+#include "VKStd.h"
+#include "VKInputAssembler.h"
+#include "VKCommands.h"
+#include "VKBuffer.h"
+
+NS_CC_BEGIN
+
+CCVKInputAssembler::CCVKInputAssembler(GFXDevice* device)
+ : GFXInputAssembler(device)
+{
+}
+
+CCVKInputAssembler::~CCVKInputAssembler()
+{
+}
+
+bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info)
+{
+ _attributes = info.attributes;
+ _vertexBuffers = info.vertexBuffers;
+ _indexBuffer = info.indexBuffer;
+ _indirectBuffer = info.indirectBuffer;
+
+ if (_indexBuffer)
+ {
+ _indexCount = _indexBuffer->getCount();
+ }
+ else if (_vertexBuffers.size())
+ {
+ _vertexCount = _vertexBuffers[0]->getCount();
+ }
+
+ _gpuInputAssembler = CC_NEW(CCVKGPUInputAssembler);
+ _gpuInputAssembler->attributes = _attributes;
+ _gpuInputAssembler->gpuVertexBuffers.resize(_vertexBuffers.size());
+
+ for (size_t i = 0; i < _gpuInputAssembler->gpuVertexBuffers.size(); ++i)
+ {
+ CCVKBuffer* vb = (CCVKBuffer*)_vertexBuffers[i];
+ _gpuInputAssembler->gpuVertexBuffers[i] = vb->gpuBuffer();
+ }
+
+ if (info.indexBuffer)
+ {
+ _gpuInputAssembler->gpuIndexBuffer = static_cast(info.indexBuffer)->gpuBuffer();
+ }
+
+ if (info.indirectBuffer)
+ {
+ _gpuInputAssembler->gpuIndirectBuffer = static_cast(info.indirectBuffer)->gpuBuffer();
+ }
+
+ CCVKCmdFuncCreateInputAssembler((CCVKDevice*)_device, _gpuInputAssembler);
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKInputAssembler::destroy()
+{
+ if (_gpuInputAssembler)
+ {
+ CCVKCmdFuncDestroyInputAssembler((CCVKDevice*)_device, _gpuInputAssembler);
+ CC_DELETE(_gpuInputAssembler);
+ _gpuInputAssembler = nullptr;
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h
new file mode 100644
index 0000000000..ff8a1fb2de
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h
@@ -0,0 +1,26 @@
+#ifndef CC_GFXVULKAN_CCVK_INPUT_ASSEMBLER_H_
+#define CC_GFXVULKAN_CCVK_INPUT_ASSEMBLER_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUInputAssembler;
+
+class CC_VULKAN_API CCVKInputAssembler : public GFXInputAssembler
+{
+public:
+ CCVKInputAssembler(GFXDevice* device);
+ ~CCVKInputAssembler();
+
+public:
+ bool initialize(const GFXInputAssemblerInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUInputAssembler* gpuInputAssembler() const { return _gpuInputAssembler; }
+
+private:
+ CCVKGPUInputAssembler* _gpuInputAssembler = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc
new file mode 100644
index 0000000000..2f784c4ea5
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc
@@ -0,0 +1,49 @@
+#include "VKStd.h"
+#include "VKPipelineLayout.h"
+#include "VKCommands.h"
+#include "VKBindingLayout.h"
+
+NS_CC_BEGIN
+
+CCVKPipelineLayout::CCVKPipelineLayout(GFXDevice* device)
+ : GFXPipelineLayout(device)
+{
+}
+
+CCVKPipelineLayout::~CCVKPipelineLayout()
+{
+}
+
+bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info)
+{
+
+ _layouts = info.layouts;
+ _pushConstantsRanges = info.pushConstantsRanges;
+
+ _gpuPipelineLayout = CC_NEW(CCVKGPUPipelineLayout);
+ _gpuPipelineLayout->pushConstantRanges = _pushConstantsRanges;
+ uint layoutCount = _layouts.size();
+ _gpuPipelineLayout->gpuBindingLayouts.resize(layoutCount);
+ for (uint i = 0u; i < layoutCount; i++)
+ {
+ _gpuPipelineLayout->gpuBindingLayouts[i] = ((CCVKBindingLayout*)_layouts[i])->gpuBindingLayout();
+ }
+
+ CCVKCmdFuncCreatePipelineLayout((CCVKDevice*)_device, _gpuPipelineLayout);
+
+ _status = GFXStatus::SUCCESS;
+ return true;
+}
+
+void CCVKPipelineLayout::destroy()
+{
+ if (_gpuPipelineLayout)
+ {
+ CCVKCmdFuncDestroyPipelineLayout((CCVKDevice*)_device, _gpuPipelineLayout);
+ CC_DELETE(_gpuPipelineLayout);
+ _gpuPipelineLayout = nullptr;
+ }
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h
new file mode 100644
index 0000000000..be186238a4
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h
@@ -0,0 +1,25 @@
+#ifndef CC_GFXVULKAN_CCVK_PIPELINE_LAYOUT_H_
+#define CC_GFXVULKAN_CCVK_PIPELINE_LAYOUT_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUPipelineLayout;
+
+class CC_VULKAN_API CCVKPipelineLayout : public GFXPipelineLayout
+{
+public:
+ CCVKPipelineLayout(GFXDevice* device);
+ ~CCVKPipelineLayout();
+
+public:
+ bool initialize(const GFXPipelineLayoutInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUPipelineLayout* gpuPipelineLayout() const { return _gpuPipelineLayout; }
+private:
+ CCVKGPUPipelineLayout* _gpuPipelineLayout = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc b/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc
new file mode 100644
index 0000000000..0822a78e40
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc
@@ -0,0 +1,60 @@
+#include "VKStd.h"
+#include "VKPipelineState.h"
+#include "VKCommands.h"
+#include "VKShader.h"
+#include "VKRenderPass.h"
+#include "VKPipelineLayout.h"
+
+NS_CC_BEGIN
+
+CCVKPipelineState::CCVKPipelineState(GFXDevice* device)
+ : GFXPipelineState(device)
+{
+}
+
+CCVKPipelineState::~CCVKPipelineState()
+{
+}
+
+bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info)
+{
+ _primitive = info.primitive;
+ _shader = info.shader;
+ _inputState = info.inputState;
+ _rasterizerState = info.rasterizerState;
+ _depthStencilState = info.depthStencilState;
+ _blendState = info.blendState;
+ _dynamicStates = info.dynamicStates;
+ _layout = info.layout;
+ _renderPass = info.renderPass;
+
+ _gpuPipelineState = CC_NEW(CCVKGPUPipelineState);
+ _gpuPipelineState->primitive = _primitive;
+ _gpuPipelineState->gpuShader = ((CCVKShader*)_shader)->gpuShader();
+ _gpuPipelineState->inputState = _inputState;
+ _gpuPipelineState->rs = _rasterizerState;
+ _gpuPipelineState->dss = _depthStencilState;
+ _gpuPipelineState->bs = _blendState;
+ _gpuPipelineState->dynamicStates = _dynamicStates;
+ _gpuPipelineState->gpuLayout = ((CCVKPipelineLayout*)_layout)->gpuPipelineLayout();
+ _gpuPipelineState->gpuRenderPass = ((CCVKRenderPass*)_renderPass)->gpuRenderPass();
+
+ CCVKCmdFuncCreatePipelineState((CCVKDevice*)_device, _gpuPipelineState);
+
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKPipelineState::destroy()
+{
+ if (_gpuPipelineState)
+ {
+ CCVKCmdFuncDestroyPipelineState((CCVKDevice*)_device, _gpuPipelineState);
+ CC_DELETE(_gpuPipelineState);
+ _gpuPipelineState = nullptr;
+ }
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineState.h b/native/cocos/renderer/gfx-vulkan/VKPipelineState.h
new file mode 100644
index 0000000000..656fec9c7f
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKPipelineState.h
@@ -0,0 +1,26 @@
+#ifndef CC_GFXVULKAN_CCVK_PIPELINE_STATE_H_
+#define CC_GFXVULKAN_CCVK_PIPELINE_STATE_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUPipelineState;
+
+class CC_VULKAN_API CCVKPipelineState : public GFXPipelineState
+{
+public:
+ CCVKPipelineState(GFXDevice* device);
+ ~CCVKPipelineState();
+
+public:
+ bool initialize(const GFXPipelineStateInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUPipelineState* gpuPipelineState() const { return _gpuPipelineState; }
+
+private:
+ CCVKGPUPipelineState* _gpuPipelineState = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.cc b/native/cocos/renderer/gfx-vulkan/VKQueue.cc
new file mode 100644
index 0000000000..746caba922
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKQueue.cc
@@ -0,0 +1,72 @@
+#include "VKStd.h"
+#include "VKQueue.h"
+#include "VKDevice.h"
+#include "VKCommands.h"
+#include "VKCommandBuffer.h"
+
+NS_CC_BEGIN
+
+CCVKQueue::CCVKQueue(GFXDevice* device)
+ : GFXQueue(device)
+{
+}
+
+CCVKQueue::~CCVKQueue()
+{
+}
+
+bool CCVKQueue::initialize(const GFXQueueInfo &info)
+{
+ _type = info.type;
+
+ _gpuQueue = CC_NEW(CCVKGPUQueue);
+ _gpuQueue->type = _type;
+ CCVKCmdFuncGetDeviceQueue((CCVKDevice*)_device, _gpuQueue);
+
+ _status = GFXStatus::SUCCESS;
+ return true;
+}
+
+void CCVKQueue::destroy()
+{
+ if (_gpuQueue)
+ {
+ _gpuQueue->vkQueue = VK_NULL_HANDLE;
+ CC_DELETE(_gpuQueue);
+ _gpuQueue = nullptr;
+ }
+ _status = GFXStatus::UNREADY;
+}
+
+void CCVKQueue::submit(const std::vector& cmdBuffs)
+{
+ if (!_isAsync)
+ {
+ _gpuQueue->commandBuffers.clear();
+ uint32_t count = cmdBuffs.size();
+ for (uint32_t i = 0u; i < count; ++i)
+ {
+ CCVKCommandBuffer* cmdBuffer = (CCVKCommandBuffer*)cmdBuffs[i];
+ _gpuQueue->commandBuffers.push(cmdBuffer->_gpuCommandBuffer->vkCommandBuffer);
+ _numDrawCalls += cmdBuffer->_numDrawCalls;
+ _numInstances += cmdBuffer->_numInstances;
+ _numTriangles += cmdBuffer->_numTriangles;
+ }
+
+ VkSubmitInfo submitInfo{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
+ submitInfo.waitSemaphoreCount = 1;
+ submitInfo.pWaitSemaphores = &_gpuQueue->waitSemaphore;
+ submitInfo.pWaitDstStageMask = &_gpuQueue->submitStageMask;
+ submitInfo.commandBufferCount = count;
+ submitInfo.pCommandBuffers = &_gpuQueue->commandBuffers[0];
+ submitInfo.signalSemaphoreCount = 1;
+ submitInfo.pSignalSemaphores = &_gpuQueue->signalSemaphore;
+
+ VK_CHECK(vkQueueSubmit(_gpuQueue->vkQueue, 1, &submitInfo, VK_NULL_HANDLE));
+
+ _gpuQueue->waitSemaphore = _gpuQueue->signalSemaphore;
+ _gpuQueue->signalSemaphore = ((CCVKDevice*)_device)->gpuSemaphorePool()->alloc();
+ }
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.h b/native/cocos/renderer/gfx-vulkan/VKQueue.h
new file mode 100644
index 0000000000..b025ba3b07
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKQueue.h
@@ -0,0 +1,33 @@
+#ifndef CC_GFXVULKAN_CCVK_QUEUE_H_
+#define CC_GFXVULKAN_CCVK_QUEUE_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUQueue;
+
+class CC_VULKAN_API CCVKQueue : public GFXQueue {
+public:
+ CCVKQueue(GFXDevice* device);
+ ~CCVKQueue();
+
+ friend class CCVKDevice;
+
+public:
+ bool initialize(const GFXQueueInfo& info);
+ void destroy();
+ void submit(const std::vector& cmd_buffs);
+
+ CC_INLINE bool isAsync() const { return _isAsync; }
+ CC_INLINE CCVKGPUQueue* gpuQueue() const { return _gpuQueue; }
+
+private:
+ CCVKGPUQueue* _gpuQueue;
+ bool _isAsync = false;
+ uint32_t _numDrawCalls = 0;
+ uint32_t _numInstances = 0;
+ uint32_t _numTriangles = 0;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc b/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc
new file mode 100644
index 0000000000..b11ac4e356
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc
@@ -0,0 +1,45 @@
+#include "VKStd.h"
+#include "VKRenderPass.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKRenderPass::CCVKRenderPass(GFXDevice* device)
+ : GFXRenderPass(device)
+{
+}
+
+CCVKRenderPass::~CCVKRenderPass()
+{
+}
+
+bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info)
+{
+ _colorAttachments = info.colorAttachments;
+ _depthStencilAttachment = info.depthStencilAttachment;
+ _subPasses = info.subPasses;
+
+ _gpuRenderPass = CC_NEW(CCVKGPURenderPass);
+ _gpuRenderPass->colorAttachments = _colorAttachments;
+ _gpuRenderPass->depthStencilAttachment = _depthStencilAttachment;
+ _gpuRenderPass->subPasses = _subPasses;
+ CCVKCmdFuncCreateRenderPass((CCVKDevice*)_device, _gpuRenderPass);
+
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKRenderPass::destroy()
+{
+ if (_gpuRenderPass)
+ {
+ CCVKCmdFuncDestroyRenderPass((CCVKDevice*)_device, _gpuRenderPass);
+ CC_DELETE(_gpuRenderPass);
+ _gpuRenderPass = nullptr;
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKRenderPass.h b/native/cocos/renderer/gfx-vulkan/VKRenderPass.h
new file mode 100644
index 0000000000..5c6bf62f9c
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKRenderPass.h
@@ -0,0 +1,26 @@
+#ifndef CC_GFXVULKAN_CCVK_RENDER_PASS_H_
+#define CC_GFXVULKAN_CCVK_RENDER_PASS_H_
+
+NS_CC_BEGIN
+
+class CCVKGPURenderPass;
+
+class CC_VULKAN_API CCVKRenderPass : public GFXRenderPass
+{
+public:
+ CCVKRenderPass(GFXDevice* device);
+ ~CCVKRenderPass();
+
+public:
+ bool initialize(const GFXRenderPassInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPURenderPass* gpuRenderPass() const { return _gpuRenderPass; }
+
+private:
+ CCVKGPURenderPass* _gpuRenderPass = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKSPIRV.h b/native/cocos/renderer/gfx-vulkan/VKSPIRV.h
new file mode 100644
index 0000000000..2befcca779
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKSPIRV.h
@@ -0,0 +1,214 @@
+#ifndef CC_GFXVULKAN_SPIRV_H_
+#define CC_GFXVULKAN_SPIRV_H_
+
+#include "SPIRV/GlslangToSpv.h"
+#include "glslang/public/ShaderLang.h"
+
+NS_CC_BEGIN
+
+namespace
+{
+ EShLanguage getShaderStage(GFXShaderType type)
+ {
+ switch (type)
+ {
+ case GFXShaderType::VERTEX: return EShLangVertex;
+ case GFXShaderType::CONTROL: return EShLangTessControl;
+ case GFXShaderType::EVALUATION: return EShLangTessEvaluation;
+ case GFXShaderType::GEOMETRY: return EShLangGeometry;
+ case GFXShaderType::FRAGMENT: return EShLangFragment;
+ case GFXShaderType::COMPUTE: return EShLangCompute;
+ default:
+ {
+ CCASSERT(false, "Unsupported GFXShaderType, convert to EShLanguage failed.");
+ return EShLangVertex;
+ }
+ }
+ }
+
+ glslang::EShTargetClientVersion getClientVersion(int vulkanMinorVersion)
+ {
+ switch (vulkanMinorVersion)
+ {
+ case 0: return glslang::EShTargetVulkan_1_0;
+ case 1: return glslang::EShTargetVulkan_1_1;
+ case 2: return glslang::EShTargetVulkan_1_2;
+ default:
+ {
+ CCASSERT(false, "Unsupported vulkan version, convert to EShTargetClientVersion failed.");
+ return glslang::EShTargetVulkan_1_0;
+ }
+ }
+ }
+
+ glslang::EShTargetLanguageVersion getTargetVersion(int vulkanMinorVersion)
+ {
+ switch (vulkanMinorVersion)
+ {
+ case 0: return glslang::EShTargetSpv_1_0;
+ case 1: return glslang::EShTargetSpv_1_3;
+ case 2: return glslang::EShTargetSpv_1_5;
+ default:
+ {
+ CCASSERT(false, "Unsupported vulkan version, convert to EShTargetLanguageVersion failed.");
+ return glslang::EShTargetSpv_1_0;
+ }
+ }
+ }
+
+ bool glslangInitialized = false;
+
+ const TBuiltInResource defaultTBuiltInResource{
+ /* .MaxLights = */ 32,
+ /* .MaxClipPlanes = */ 6,
+ /* .MaxTextureUnits = */ 32,
+ /* .MaxTextureCoords = */ 32,
+ /* .MaxVertexAttribs = */ 64,
+ /* .MaxVertexUniformComponents = */ 4096,
+ /* .MaxVaryingFloats = */ 64,
+ /* .MaxVertexTextureImageUnits = */ 32,
+ /* .MaxCombinedTextureImageUnits = */ 80,
+ /* .MaxTextureImageUnits = */ 32,
+ /* .MaxFragmentUniformComponents = */ 4096,
+ /* .MaxDrawBuffers = */ 32,
+ /* .MaxVertexUniformVectors = */ 128,
+ /* .MaxVaryingVectors = */ 8,
+ /* .MaxFragmentUniformVectors = */ 16,
+ /* .MaxVertexOutputVectors = */ 16,
+ /* .MaxFragmentInputVectors = */ 15,
+ /* .MinProgramTexelOffset = */ -8,
+ /* .MaxProgramTexelOffset = */ 7,
+ /* .MaxClipDistances = */ 8,
+ /* .MaxComputeWorkGroupCountX = */ 65535,
+ /* .MaxComputeWorkGroupCountY = */ 65535,
+ /* .MaxComputeWorkGroupCountZ = */ 65535,
+ /* .MaxComputeWorkGroupSizeX = */ 1024,
+ /* .MaxComputeWorkGroupSizeY = */ 1024,
+ /* .MaxComputeWorkGroupSizeZ = */ 64,
+ /* .MaxComputeUniformComponents = */ 1024,
+ /* .MaxComputeTextureImageUnits = */ 16,
+ /* .MaxComputeImageUniforms = */ 8,
+ /* .MaxComputeAtomicCounters = */ 8,
+ /* .MaxComputeAtomicCounterBuffers = */ 1,
+ /* .MaxVaryingComponents = */ 60,
+ /* .MaxVertexOutputComponents = */ 64,
+ /* .MaxGeometryInputComponents = */ 64,
+ /* .MaxGeometryOutputComponents = */ 128,
+ /* .MaxFragmentInputComponents = */ 128,
+ /* .MaxImageUnits = */ 8,
+ /* .MaxCombinedImageUnitsAndFragmentOutputs = */ 8,
+ /* .MaxCombinedShaderOutputResources = */ 8,
+ /* .MaxImageSamples = */ 0,
+ /* .MaxVertexImageUniforms = */ 0,
+ /* .MaxTessControlImageUniforms = */ 0,
+ /* .MaxTessEvaluationImageUniforms = */ 0,
+ /* .MaxGeometryImageUniforms = */ 0,
+ /* .MaxFragmentImageUniforms = */ 8,
+ /* .MaxCombinedImageUniforms = */ 8,
+ /* .MaxGeometryTextureImageUnits = */ 16,
+ /* .MaxGeometryOutputVertices = */ 256,
+ /* .MaxGeometryTotalOutputComponents = */ 1024,
+ /* .MaxGeometryUniformComponents = */ 1024,
+ /* .MaxGeometryVaryingComponents = */ 64,
+ /* .MaxTessControlInputComponents = */ 128,
+ /* .MaxTessControlOutputComponents = */ 128,
+ /* .MaxTessControlTextureImageUnits = */ 16,
+ /* .MaxTessControlUniformComponents = */ 1024,
+ /* .MaxTessControlTotalOutputComponents = */ 4096,
+ /* .MaxTessEvaluationInputComponents = */ 128,
+ /* .MaxTessEvaluationOutputComponents = */ 128,
+ /* .MaxTessEvaluationTextureImageUnits = */ 16,
+ /* .MaxTessEvaluationUniformComponents = */ 1024,
+ /* .MaxTessPatchComponents = */ 120,
+ /* .MaxPatchVertices = */ 32,
+ /* .MaxTessGenLevel = */ 64,
+ /* .MaxViewports = */ 16,
+ /* .MaxVertexAtomicCounters = */ 0,
+ /* .MaxTessControlAtomicCounters = */ 0,
+ /* .MaxTessEvaluationAtomicCounters = */ 0,
+ /* .MaxGeometryAtomicCounters = */ 0,
+ /* .MaxFragmentAtomicCounters = */ 8,
+ /* .MaxCombinedAtomicCounters = */ 8,
+ /* .MaxAtomicCounterBindings = */ 1,
+ /* .MaxVertexAtomicCounterBuffers = */ 0,
+ /* .MaxTessControlAtomicCounterBuffers = */ 0,
+ /* .MaxTessEvaluationAtomicCounterBuffers = */ 0,
+ /* .MaxGeometryAtomicCounterBuffers = */ 0,
+ /* .MaxFragmentAtomicCounterBuffers = */ 1,
+ /* .MaxCombinedAtomicCounterBuffers = */ 1,
+ /* .MaxAtomicCounterBufferSize = */ 16384,
+ /* .MaxTransformFeedbackBuffers = */ 4,
+ /* .MaxTransformFeedbackInterleavedComponents = */ 64,
+ /* .MaxCullDistances = */ 8,
+ /* .MaxCombinedClipAndCullDistances = */ 8,
+ /* .MaxSamples = */ 4,
+ /* .maxMeshOutputVerticesNV = */ 256,
+ /* .maxMeshOutputPrimitivesNV = */ 512,
+ /* .maxMeshWorkGroupSizeX_NV = */ 32,
+ /* .maxMeshWorkGroupSizeY_NV = */ 1,
+ /* .maxMeshWorkGroupSizeZ_NV = */ 1,
+ /* .maxTaskWorkGroupSizeX_NV = */ 32,
+ /* .maxTaskWorkGroupSizeY_NV = */ 1,
+ /* .maxTaskWorkGroupSizeZ_NV = */ 1,
+ /* .maxMeshViewCountNV = */ 4,
+
+ /* .limits = */ {
+ /* .nonInductiveForLoops = */ 1,
+ /* .whileLoops = */ 1,
+ /* .doWhileLoops = */ 1,
+ /* .generalUniformIndexing = */ 1,
+ /* .generalAttributeMatrixVectorIndexing = */ 1,
+ /* .generalVaryingIndexing = */ 1,
+ /* .generalSamplerIndexing = */ 1,
+ /* .generalVariableIndexing = */ 1,
+ /* .generalConstantMatrixVectorIndexing = */ 1,
+ } };
+
+ const std::vector GLSL2SPIRV(GFXShaderType type, String source, int vulkanMinorVersion = 2)
+ {
+ if (!glslangInitialized)
+ {
+ glslang::InitializeProcess();
+ glslangInitialized = true;
+ }
+
+ auto stage = getShaderStage(type);
+ auto string = source.c_str();
+ glslang::TShader shader(stage);
+ shader.setStrings(&string, 1);
+
+ int clientInputSemanticsVersion = 100 + vulkanMinorVersion * 10;
+ glslang::EShTargetClientVersion clientVersion = getClientVersion(vulkanMinorVersion);
+ glslang::EShTargetLanguageVersion targetVersion = getTargetVersion(vulkanMinorVersion);
+
+ shader.setEnvInput(glslang::EShSourceGlsl, stage, glslang::EShClientVulkan, clientInputSemanticsVersion);
+ shader.setEnvClient(glslang::EShClientVulkan, clientVersion);
+ shader.setEnvTarget(glslang::EShTargetSpv, targetVersion);
+
+ EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules);
+
+ if (!shader.parse(&defaultTBuiltInResource, clientInputSemanticsVersion, false, messages))
+ {
+ CC_LOG_ERROR("GLSL Parsing Failed:\n%s\n%s", shader.getInfoLog(), shader.getInfoDebugLog());
+ }
+
+ glslang::TProgram program;
+ program.addShader(&shader);
+
+ if (!program.link(messages))
+ {
+ CC_LOG_ERROR("GLSL Linking Failed:\n%s\n%s", program.getInfoLog(), program.getInfoDebugLog());
+ }
+
+ std::vector spirv;
+ spv::SpvBuildLogger logger;
+ glslang::SpvOptions spvOptions;
+ glslang::GlslangToSpv(*program.getIntermediate(stage), spirv, &logger, &spvOptions);
+
+ return std::move(spirv);
+ }
+}
+
+#endif
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKSampler.cc b/native/cocos/renderer/gfx-vulkan/VKSampler.cc
new file mode 100644
index 0000000000..d521c68d75
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKSampler.cc
@@ -0,0 +1,55 @@
+#include "VKStd.h"
+#include "VKSampler.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKSampler::CCVKSampler(GFXDevice* device)
+ : GFXSampler(device) {
+}
+
+CCVKSampler::~CCVKSampler() {
+}
+
+bool CCVKSampler::initialize(const GFXSamplerInfo &info) {
+ _name = info.name;
+ _minFilter = info.minFilter;
+ _magFilter = info.magFilter;
+ _mipFilter = info.mipFilter;
+ _addressU = info.addressU;
+ _addressV = info.addressV;
+ _addressW = info.addressW;
+ _maxAnisotropy = info.maxAnisotropy;
+ _cmpFunc = info.cmpFunc;
+ _borderColor = info.borderColor;
+ _minLOD = info.minLOD;
+ _maxLOD = info.maxLOD;
+ _mipLODBias = info.mipLODBias;
+
+ _gpuSampler = CC_NEW(CCVKGPUSampler);
+ _gpuSampler->minFilter = _minFilter;
+ _gpuSampler->magFilter = _magFilter;
+ _gpuSampler->mipFilter = _mipFilter;
+ _gpuSampler->addressU = _addressU;
+ _gpuSampler->addressV = _addressV;
+ _gpuSampler->addressW = _addressW;
+ _gpuSampler->minLOD = _minLOD;
+ _gpuSampler->maxLOD = _maxLOD;
+
+ _status = GFXStatus::SUCCESS;
+
+ CCVKCmdFuncCreateSampler((CCVKDevice*)_device, _gpuSampler);
+
+ return true;
+}
+
+void CCVKSampler::destroy() {
+ if (_gpuSampler) {
+ CCVKCmdFuncDestroySampler((CCVKDevice*)_device, _gpuSampler);
+ CC_DELETE(_gpuSampler);
+ _gpuSampler = nullptr;
+ }
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKSampler.h b/native/cocos/renderer/gfx-vulkan/VKSampler.h
new file mode 100644
index 0000000000..f4d4d69364
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKSampler.h
@@ -0,0 +1,25 @@
+#ifndef CC_GFXVULKAN_CCVK_SAMPLER_H_
+#define CC_GFXVULKAN_CCVK_SAMPLER_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUSampler;
+
+class CC_VULKAN_API CCVKSampler : public GFXSampler {
+public:
+ CCVKSampler(GFXDevice* device);
+ ~CCVKSampler();
+
+public:
+ bool initialize(const GFXSamplerInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUSampler* gpuSampler() const { return _gpuSampler; }
+
+private:
+ CCVKGPUSampler* _gpuSampler = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKShader.cc b/native/cocos/renderer/gfx-vulkan/VKShader.cc
new file mode 100644
index 0000000000..f02d0a3f41
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKShader.cc
@@ -0,0 +1,52 @@
+#include "VKStd.h"
+#include "VKShader.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKShader::CCVKShader(GFXDevice* device)
+ : GFXShader(device)
+{
+}
+
+CCVKShader::~CCVKShader()
+{
+}
+
+bool CCVKShader::initialize(const GFXShaderInfo &info)
+{
+ _name = info.name;
+ _stages = info.stages;
+ _blocks = info.blocks;
+ _samplers = info.samplers;
+
+ _gpuShader = CC_NEW(CCVKGPUShader);
+ _gpuShader->name = _name;
+ _gpuShader->blocks = _blocks;
+ _gpuShader->samplers = _samplers;
+ for (const auto& stage : _stages)
+ {
+ CCVKGPUShaderStage gpuShaderStage = { stage.type, stage.source, stage.macros };
+ _gpuShader->gpuStages.emplace_back(std::move(gpuShaderStage));
+ }
+
+ CCVKCmdFuncCreateShader((CCVKDevice*)_device, _gpuShader);
+
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKShader::destroy()
+{
+ if (_gpuShader)
+ {
+ CCVKCmdFuncDestroyShader((CCVKDevice*)_device, _gpuShader);
+ CC_DELETE(_gpuShader);
+ _gpuShader = nullptr;
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKShader.h b/native/cocos/renderer/gfx-vulkan/VKShader.h
new file mode 100644
index 0000000000..b89b3dbe40
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKShader.h
@@ -0,0 +1,24 @@
+#ifndef CC_GFXVULKAN_CCVK_SHADER_H_
+#define CC_GFXVULKAN_CCVK_SHADER_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUShader;
+
+class CC_VULKAN_API CCVKShader : public GFXShader {
+ public:
+ CCVKShader(GFXDevice* device);
+ ~CCVKShader();
+
+ public:
+ bool initialize(const GFXShaderInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUShader* gpuShader() const { return _gpuShader; }
+ private:
+ CCVKGPUShader* _gpuShader = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKStateCache.h b/native/cocos/renderer/gfx-vulkan/VKStateCache.h
new file mode 100644
index 0000000000..3ca73132f2
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKStateCache.h
@@ -0,0 +1,34 @@
+#ifndef CC_GFXVULKAN_STATE_CACHE_H_
+#define CC_GFXVULKAN_STATE_CACHE_H_
+
+NS_CC_BEGIN
+
+class CCVKStateCache : public Object {
+public:
+ //GLuint glArrayBuffer = 0;
+ //GLuint glElementArrayBuffer = 0;
+ //GLuint glUniformBuffer = 0;
+ //GLuint glBindUBOs[GFX_MAX_BUFFER_BINDINGS] = { 0 };
+ //GLuint glVAO = 0;
+ uint texUint = 0;
+ //GLuint glTextures[GFX_MAX_TEXTURE_UNITS] = { 0 };
+ //GLuint glSamplers[GFX_MAX_TEXTURE_UNITS] = { 0 };
+ //GLuint glProgram = 0;
+ bool glEnabledAttribLocs[GFX_MAX_VERTEX_ATTRIBUTES] = { false };
+ bool glCurrentAttribLocs[GFX_MAX_VERTEX_ATTRIBUTES] = { false };
+ //GLuint glFramebuffer = 0;
+ //GLuint glReadFBO = 0;
+ GFXViewport viewport;
+ GFXRect scissor;
+ GFXRasterizerState rs;
+ GFXDepthStencilState dss;
+ GFXBlendState bs;
+ bool isCullFaceEnabled = true;
+ bool isStencilTestEnabled = false;
+
+ CCVKStateCache() {}
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKStd.cc b/native/cocos/renderer/gfx-vulkan/VKStd.cc
new file mode 100644
index 0000000000..a074daa4b8
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKStd.cc
@@ -0,0 +1 @@
+#include "VKStd.h"
diff --git a/native/cocos/renderer/gfx-vulkan/VKStd.h b/native/cocos/renderer/gfx-vulkan/VKStd.h
new file mode 100644
index 0000000000..b751957570
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKStd.h
@@ -0,0 +1,41 @@
+#ifndef __CC_GFXVULKAN_VK_STD_H__
+#define __CC_GFXVULKAN_VK_STD_H__
+
+#include
+
+#if (CC_PLATFORM == CC_PLATFORM_WINDOWS)
+# if defined(CC_STATIC)
+# define CC_VULKAN_API
+# else
+# ifdef CC_VK_EXPORTS
+# define CC_VULKAN_API __declspec(dllexport)
+# else
+# define CC_VULKAN_API __declspec(dllimport)
+# endif
+# endif
+#else
+# define CC_VULKAN_API
+#endif
+
+#define VK_CHECK(x) \
+ do \
+ { \
+ VkResult err = x; \
+ if (err) \
+ { \
+ CC_LOG_ERROR("Detected Vulkan error: %d", err); \
+ abort(); \
+ } \
+ } while (0)
+
+#define ASSERT_VK_HANDLE(handle) \
+ do \
+ { \
+ if ((handle) == VK_NULL_HANDLE) \
+ { \
+ CC_LOG_ERROR("Handle is NULL"); \
+ abort(); \
+ } \
+ } while (0)
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKTexture.cc b/native/cocos/renderer/gfx-vulkan/VKTexture.cc
new file mode 100644
index 0000000000..4149bd66d3
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKTexture.cc
@@ -0,0 +1,158 @@
+#include "VKStd.h"
+#include "VKTexture.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKTexture::CCVKTexture(GFXDevice* device)
+ : GFXTexture(device)
+{
+}
+
+CCVKTexture::~CCVKTexture()
+{
+}
+
+bool CCVKTexture::initialize(const GFXTextureInfo &info)
+{
+ _type = info.type;
+ _usage = info.usage;
+ _format = info.format;
+ _width = info.width;
+ _height = info.height;
+ _depth = info.depth;
+ _arrayLayer = info.arrayLayer;
+ _mipLevel = info.mipLevel;
+ _samples = info.samples;
+ _flags = info.flags;
+ _size = GFXFormatSize(_format, _width, _height, _depth);
+
+ if (_flags & GFXTextureFlags::BAKUP_BUFFER)
+ {
+ _buffer = (uint8_t*)CC_MALLOC(_size);
+ _device->getMemoryStatus().textureSize += _size;
+ }
+
+ _gpuTexture = CC_NEW(CCVKGPUTexture);
+ _gpuTexture->type = _type;
+
+ switch (_type)
+ {
+ case GFXTextureType::TEX1D:
+ {
+ if (_arrayLayer)
+ {
+ _gpuTexture->viewType = _arrayLayer <= 1 ? GFXTextureViewType::TV1D : GFXTextureViewType::TV1D_ARRAY;
+ }
+ else
+ {
+ _gpuTexture->viewType = GFXTextureViewType::TV1D;
+ }
+ break;
+ }
+ case GFXTextureType::TEX2D:
+ {
+ if (_arrayLayer)
+ {
+ if (_arrayLayer <= 1)
+ {
+ _gpuTexture->viewType = GFXTextureViewType::TV2D;
+ }
+ else if (_flags & GFXTextureFlagBit::CUBEMAP)
+ {
+ _gpuTexture->viewType = GFXTextureViewType::CUBE;
+ }
+ else
+ {
+ _gpuTexture->viewType = GFXTextureViewType::TV2D_ARRAY;
+ }
+ }
+ else
+ {
+ _gpuTexture->viewType = GFXTextureViewType::TV2D;
+ }
+ break;
+ }
+ case GFXTextureType::TEX3D:
+ {
+ _gpuTexture->viewType = GFXTextureViewType::TV3D;
+ break;
+ }
+ default:
+ {
+ _gpuTexture->viewType = GFXTextureViewType::TV2D;
+ }
+ }
+
+ _gpuTexture->format = _format;
+ _gpuTexture->usage = _usage;
+ _gpuTexture->width = _width;
+ _gpuTexture->height = _height;
+ _gpuTexture->depth = _depth;
+ _gpuTexture->size = _size;
+ _gpuTexture->arrayLayer = _arrayLayer;
+ _gpuTexture->mipLevel = _mipLevel;
+ _gpuTexture->samples = _samples;
+ _gpuTexture->flags = _flags;
+ _gpuTexture->isPowerOf2 = math::IsPowerOfTwo(_width) && math::IsPowerOfTwo(_height);
+
+ CCVKCmdFuncCreateTexture((CCVKDevice*)_device, _gpuTexture);
+ _device->getMemoryStatus().textureSize += _size;
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKTexture::destroy()
+{
+ if (_gpuTexture)
+ {
+ CCVKCmdFuncDestroyTexture((CCVKDevice*)_device, _gpuTexture);
+ _device->getMemoryStatus().textureSize -= _size;
+ CC_DELETE(_gpuTexture);
+ _gpuTexture = nullptr;
+ }
+
+ if (_buffer)
+ {
+ CC_FREE(_buffer);
+ _device->getMemoryStatus().textureSize -= _size;
+ _buffer = nullptr;
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+void CCVKTexture::resize(uint width, uint height)
+{
+ uint size = GFXFormatSize(_format, width, height, _depth);
+ if (_size != size)
+ {
+ const uint old_size = _size;
+ _width = width;
+ _height = height;
+ _size = size;
+
+ GFXMemoryStatus& status = _device->getMemoryStatus();
+ _gpuTexture->width = _width;
+ _gpuTexture->height = _height;
+ _gpuTexture->size = _size;
+ CCVKCmdFuncResizeTexture((CCVKDevice*)_device, _gpuTexture);
+ status.bufferSize -= old_size;
+ status.bufferSize += _size;
+
+ if (_buffer)
+ {
+ const uint8_t* old_buff = _buffer;
+ _buffer = (uint8_t*)CC_MALLOC(_size);
+ memcpy(_buffer, old_buff, old_size);
+ CC_FREE(_buffer);
+ status.bufferSize -= old_size;
+ status.bufferSize += _size;
+ }
+ }
+
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKTexture.h b/native/cocos/renderer/gfx-vulkan/VKTexture.h
new file mode 100644
index 0000000000..e515273b67
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKTexture.h
@@ -0,0 +1,26 @@
+#ifndef CC_GFXVULKAN_CCVK_TEXTURE_H_
+#define CC_GFXVULKAN_CCVK_TEXTURE_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUTexture;
+
+class CC_VULKAN_API CCVKTexture : public GFXTexture {
+ public:
+ CCVKTexture(GFXDevice* device);
+ ~CCVKTexture();
+
+ public:
+ bool initialize(const GFXTextureInfo& info);
+ void destroy();
+ void resize(uint width, uint height);
+
+ CC_INLINE CCVKGPUTexture* gpuTexture() const { return _gpuTexture; }
+
+ private:
+ CCVKGPUTexture* _gpuTexture = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKTextureView.cc b/native/cocos/renderer/gfx-vulkan/VKTextureView.cc
new file mode 100644
index 0000000000..25e21db833
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKTextureView.cc
@@ -0,0 +1,54 @@
+#include "VKStd.h"
+#include "VKTextureView.h"
+#include "VKTexture.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKTextureView::CCVKTextureView(GFXDevice* device)
+ : GFXTextureView(device)
+{
+}
+
+CCVKTextureView::~CCVKTextureView()
+{
+}
+
+bool CCVKTextureView::initialize(const GFXTextureViewInfo &info)
+{
+
+ _texture = info.texture;
+ _type = info.type;
+ _format = info.format;
+ _baseLevel = info.baseLevel;
+ _levelCount = info.levelCount;
+ _baseLayer = info.baseLayer;
+ _layerCount = info.layerCount;
+
+ _gpuTexView = CC_NEW(CCVKGPUTextureView);
+ _gpuTexView->gpuTexture = static_cast(_texture)->gpuTexture();
+ _gpuTexView->type = _type;
+ _gpuTexView->format = _format;
+ _gpuTexView->baseLevel = info.baseLevel;
+ _gpuTexView->levelCount = info.levelCount;
+
+ CCVKCmdFuncCreateTextureView((CCVKDevice*)_device, _gpuTexView);
+
+ _status = GFXStatus::SUCCESS;
+
+ return true;
+}
+
+void CCVKTextureView::destroy()
+{
+ if (_gpuTexView)
+ {
+ CCVKCmdFuncDestroyTextureView((CCVKDevice*)_device, _gpuTexView);
+ CC_DELETE(_gpuTexView);
+ _gpuTexView = nullptr;
+ }
+ _texture = nullptr;
+ _status = GFXStatus::UNREADY;
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKTextureView.h b/native/cocos/renderer/gfx-vulkan/VKTextureView.h
new file mode 100644
index 0000000000..bc30b4c9fd
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKTextureView.h
@@ -0,0 +1,25 @@
+#ifndef CC_GFXVULKAN_CCVK_TEXTURE_VIEW_H_
+#define CC_GFXVULKAN_CCVK_TEXTURE_VIEW_H_
+
+NS_CC_BEGIN
+
+class CCVKGPUTextureView;
+
+class CC_VULKAN_API CCVKTextureView : public GFXTextureView {
+public:
+ CCVKTextureView(GFXDevice* device);
+ ~CCVKTextureView();
+
+public:
+ bool initialize(const GFXTextureViewInfo& info);
+ void destroy();
+
+ CC_INLINE CCVKGPUTextureView* gpuTexView() const { return _gpuTexView; }
+
+private:
+ CCVKGPUTextureView* _gpuTexView = nullptr;
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKUtils.h b/native/cocos/renderer/gfx-vulkan/VKUtils.h
new file mode 100644
index 0000000000..9c7905ea74
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKUtils.h
@@ -0,0 +1,52 @@
+#ifndef __CC_GFXVULKAN_VK_UTILS_H__
+#define __CC_GFXVULKAN_VK_UTILS_H__
+
+#include "volk.h"
+
+namespace
+{
+
+ template
+ char(*countof_helper(T(&_Array)[Size]))[Size];
+
+ #define COUNTOF(array) (sizeof(*countof_helper(array)) + 0)
+
+ template
+ uint32_t toU32(T value)
+ {
+ static_assert(std::is_arithmetic::value, "T must be numeric");
+
+ if (static_cast(value) > static_cast(std::numeric_limits::max()))
+ {
+ throw std::runtime_error("to_u32() failed, value is too big to be converted to uint32_t");
+ }
+
+ return static_cast(value);
+ }
+
+ bool isLayerSupported(const char * required, const std::vector &available)
+ {
+ for (auto &availableLayer : available)
+ {
+ if (strcmp(availableLayer.layerName, required) == 0)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool isExtensionSupported(const char * required, const std::vector &available)
+ {
+ for (auto &availableExtension : available)
+ {
+ if (strcmp(availableExtension.extensionName, required) == 0)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+}
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/VKWindow.cc b/native/cocos/renderer/gfx-vulkan/VKWindow.cc
new file mode 100644
index 0000000000..fcd3c9bb7d
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKWindow.cc
@@ -0,0 +1,176 @@
+#include "VKStd.h"
+#include "VKWindow.h"
+#include "VKCommands.h"
+
+NS_CC_BEGIN
+
+CCVKWindow::CCVKWindow(GFXDevice* device)
+ : GFXWindow(device)
+{
+}
+
+CCVKWindow::~CCVKWindow()
+{
+}
+
+bool CCVKWindow::initialize(const GFXWindowInfo &info)
+{
+ _title = info.title;
+ _left = info.left;
+ _top = info.top;
+ _width = info.width;
+ _height = info.height;
+ _nativeWidth = _width;
+ _nativeHeight = _height;
+ _colorFmt = info.colorFmt;
+ _depthStencilFmt = info.depthStencilFmt;
+ _isOffscreen = info.isOffscreen;
+ _isFullscreen = info.isFullscreen;
+
+ // Create render pass
+
+ GFXRenderPassInfo renderPassInfo;
+
+ GFXColorAttachment colorAttachment;
+ colorAttachment.format = _colorFmt;
+ colorAttachment.loadOp = GFXLoadOp::CLEAR;
+ colorAttachment.storeOp = GFXStoreOp::STORE;
+ colorAttachment.sampleCount = 1;
+ colorAttachment.beginLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL;
+ colorAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
+ renderPassInfo.colorAttachments.emplace_back(colorAttachment);
+
+ GFXDepthStencilAttachment& depthStencilAttachment = renderPassInfo.depthStencilAttachment;
+ depthStencilAttachment.format = _depthStencilFmt;
+ depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR;
+ depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE;
+ depthStencilAttachment.stencilLoadOp = GFXLoadOp::CLEAR;
+ depthStencilAttachment.stencilStoreOp = GFXStoreOp::STORE;
+ depthStencilAttachment.sampleCount = 1;
+ depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+ depthStencilAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
+
+ _renderPass = _device->createRenderPass(renderPassInfo);
+
+ // Create texture & texture views
+ if (_isOffscreen)
+ {
+ if (_colorFmt != GFXFormat::UNKNOWN)
+ {
+ GFXTextureInfo colorTexInfo;
+ colorTexInfo.type = GFXTextureType::TEX2D;
+ colorTexInfo.usage = GFXTextureUsageBit::COLOR_ATTACHMENT | GFXTextureUsageBit::SAMPLED;
+ colorTexInfo.format = _colorFmt;
+ colorTexInfo.width = _width;
+ colorTexInfo.height = _height;
+ colorTexInfo.depth = 1;
+ colorTexInfo.arrayLayer = 1;
+ colorTexInfo.mipLevel = 1;
+ _colorTex = _device->createTexture(colorTexInfo);
+
+ GFXTextureViewInfo colorTexViewInfo;
+ colorTexViewInfo.texture = _colorTex;
+ colorTexViewInfo.type = GFXTextureViewType::TV2D;
+ colorTexViewInfo.format = _colorFmt;
+ colorTexViewInfo.baseLevel = 0;
+ colorTexViewInfo.levelCount = 1;
+ colorTexViewInfo.baseLayer = 0;
+ colorTexViewInfo.layerCount = 1;
+ _colorTexView = _device->createTextureView(colorTexViewInfo);
+ }
+ if (_depthStencilFmt != GFXFormat::UNKNOWN)
+ {
+ GFXTextureInfo depthStecnilTexInfo;
+ depthStecnilTexInfo.type = GFXTextureType::TEX2D;
+ depthStecnilTexInfo.usage = GFXTextureUsageBit::DEPTH_STENCIL_ATTACHMENT | GFXTextureUsageBit::SAMPLED;
+ depthStecnilTexInfo.format = _depthStencilFmt;
+ depthStecnilTexInfo.width = _width;
+ depthStecnilTexInfo.height = _height;
+ depthStecnilTexInfo.depth = 1;
+ depthStecnilTexInfo.arrayLayer = 1;
+ depthStecnilTexInfo.mipLevel = 1;
+ _depthStencilTex = _device->createTexture(depthStecnilTexInfo);
+
+ GFXTextureViewInfo depthStecnilTexViewInfo;
+ depthStecnilTexViewInfo.texture = _depthStencilTex;
+ depthStecnilTexViewInfo.type = GFXTextureViewType::TV2D;
+ depthStecnilTexViewInfo.format = _colorFmt;
+ depthStecnilTexViewInfo.baseLevel = 0;
+ depthStecnilTexViewInfo.levelCount = 1;
+ depthStecnilTexViewInfo.baseLayer = 0;
+ depthStecnilTexViewInfo.layerCount = 1;
+ _depthStencilTexView = _device->createTextureView(depthStecnilTexViewInfo);
+ }
+ }
+
+ GFXFramebufferInfo fboInfo;
+ fboInfo.renderPass = _renderPass;
+ if (_colorTexView)
+ fboInfo.colorViews.push_back(_colorTexView);
+ fboInfo.depthStencilView = _depthStencilTexView;
+ fboInfo.isOffscreen = _isOffscreen;
+ _framebuffer = _device->createFramebuffer(fboInfo);
+
+ _status = GFXStatus::SUCCESS;
+ return true;
+}
+
+void CCVKWindow::destroy()
+{
+ CC_SAFE_DESTROY(_renderPass);
+ CC_SAFE_DESTROY(_colorTexView);
+ CC_SAFE_DESTROY(_colorTex);
+ CC_SAFE_DESTROY(_depthStencilTexView);
+ CC_SAFE_DESTROY(_depthStencilTex);
+ CC_SAFE_DESTROY(_framebuffer);
+
+ _status = GFXStatus::UNREADY;
+}
+
+void CCVKWindow::resize(uint width, uint height)
+{
+ _width = width;
+ _height = height;
+
+ if (width > _nativeWidth || height > _nativeHeight)
+ {
+ _nativeWidth = width;
+ _nativeHeight = height;
+
+ if (_colorTex)
+ {
+ _colorTex->resize(width, height);
+ _colorTexView->destroy();
+
+ GFXTextureViewInfo colorTexViewInfo;
+ colorTexViewInfo.type = GFXTextureViewType::TV2D;
+ colorTexViewInfo.format = _colorFmt;
+ _colorTexView->initialize(colorTexViewInfo);
+ }
+
+ if (_depthStencilTex)
+ {
+ _depthStencilTex->resize(width, height);
+ _depthStencilTexView->destroy();
+
+ GFXTextureViewInfo depth_stencil_tex_view__info;
+ depth_stencil_tex_view__info.type = GFXTextureViewType::TV2D;
+ depth_stencil_tex_view__info.format = _depthStencilFmt;
+ _depthStencilTexView->initialize(depth_stencil_tex_view__info);
+ }
+
+ if (_framebuffer)
+ {
+ _framebuffer->destroy();
+
+ GFXFramebufferInfo fboInfo;
+ fboInfo.isOffscreen = _isOffscreen;
+ fboInfo.renderPass = _renderPass;
+ fboInfo.colorViews.push_back(_colorTexView);
+ fboInfo.depthStencilView = _depthStencilTexView;
+ _framebuffer->initialize(fboInfo);
+ }
+ }
+}
+
+NS_CC_END
diff --git a/native/cocos/renderer/gfx-vulkan/VKWindow.h b/native/cocos/renderer/gfx-vulkan/VKWindow.h
new file mode 100644
index 0000000000..4fae893dec
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/VKWindow.h
@@ -0,0 +1,20 @@
+#ifndef CC_GFXVULKAN_CCVK_WINDOW_H_
+#define CC_GFXVULKAN_CCVK_WINDOW_H_
+
+NS_CC_BEGIN
+
+class CC_VULKAN_API CCVKWindow : public GFXWindow
+{
+public:
+ CCVKWindow(GFXDevice* device);
+ ~CCVKWindow();
+
+public:
+ bool initialize(const GFXWindowInfo& info);
+ void destroy();
+ void resize(uint width, uint height);
+};
+
+NS_CC_END
+
+#endif
diff --git a/native/cocos/renderer/gfx-vulkan/volk.c b/native/cocos/renderer/gfx-vulkan/volk.c
new file mode 100644
index 0000000000..5e330bd477
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/volk.c
@@ -0,0 +1,1741 @@
+/* This file is part of volk library; see volk.h for version/license details */
+/* clang-format off */
+#include "volk.h"
+
+#ifdef _WIN32
+ typedef const char* LPCSTR;
+ typedef struct HINSTANCE__* HINSTANCE;
+ typedef HINSTANCE HMODULE;
+ #ifdef _WIN64
+ typedef __int64 (__stdcall* FARPROC)(void);
+ #else
+ typedef int (__stdcall* FARPROC)(void);
+ #endif
+#else
+# include
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+__declspec(dllimport) HMODULE __stdcall LoadLibraryA(LPCSTR);
+__declspec(dllimport) FARPROC __stdcall GetProcAddress(HMODULE, LPCSTR);
+#endif
+
+static VkInstance loadedInstance = VK_NULL_HANDLE;
+static VkDevice loadedDevice = VK_NULL_HANDLE;
+
+static void volkGenLoadLoader(void* context, PFN_vkVoidFunction (*load)(void*, const char*));
+static void volkGenLoadInstance(void* context, PFN_vkVoidFunction (*load)(void*, const char*));
+static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, const char*));
+static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context, PFN_vkVoidFunction (*load)(void*, const char*));
+
+static PFN_vkVoidFunction vkGetInstanceProcAddrStub(void* context, const char* name)
+{
+ return vkGetInstanceProcAddr((VkInstance)context, name);
+}
+
+static PFN_vkVoidFunction vkGetDeviceProcAddrStub(void* context, const char* name)
+{
+ return vkGetDeviceProcAddr((VkDevice)context, name);
+}
+
+VkResult volkInitialize(void)
+{
+#if defined(_WIN32)
+ HMODULE module = LoadLibraryA("vulkan-1.dll");
+ if (!module)
+ return VK_ERROR_INITIALIZATION_FAILED;
+
+ // note: function pointer is cast through void function pointer to silence cast-function-type warning on gcc8
+ vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)(void(*)(void))GetProcAddress(module, "vkGetInstanceProcAddr");
+#elif defined(__APPLE__)
+ void* module = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
+ if (!module)
+ module = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
+ if (!module)
+ module = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL);
+ if (!module)
+ return VK_ERROR_INITIALIZATION_FAILED;
+
+ vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(module, "vkGetInstanceProcAddr");
+#else
+ void* module = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
+ if (!module)
+ module = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL);
+ if (!module)
+ return VK_ERROR_INITIALIZATION_FAILED;
+
+ vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(module, "vkGetInstanceProcAddr");
+#endif
+
+ volkGenLoadLoader(NULL, vkGetInstanceProcAddrStub);
+
+ return VK_SUCCESS;
+}
+
+void volkInitializeCustom(PFN_vkGetInstanceProcAddr handler)
+{
+ vkGetInstanceProcAddr = handler;
+
+ volkGenLoadLoader(NULL, vkGetInstanceProcAddrStub);
+}
+
+uint32_t volkGetInstanceVersion(void)
+{
+#if defined(VK_VERSION_1_1)
+ uint32_t apiVersion = 0;
+ if (vkEnumerateInstanceVersion && vkEnumerateInstanceVersion(&apiVersion) == VK_SUCCESS)
+ return apiVersion;
+#endif
+
+ if (vkCreateInstance)
+ return VK_API_VERSION_1_0;
+
+ return 0;
+}
+
+void volkLoadInstance(VkInstance instance)
+{
+ loadedInstance = instance;
+ volkGenLoadInstance(instance, vkGetInstanceProcAddrStub);
+ volkGenLoadDevice(instance, vkGetInstanceProcAddrStub);
+}
+
+VkInstance volkGetLoadedInstance()
+{
+ return loadedInstance;
+}
+
+void volkLoadDevice(VkDevice device)
+{
+ loadedDevice = device;
+ volkGenLoadDevice(device, vkGetDeviceProcAddrStub);
+}
+
+VkDevice volkGetLoadedDevice()
+{
+ return loadedDevice;
+}
+
+void volkLoadDeviceTable(struct VolkDeviceTable* table, VkDevice device)
+{
+ volkGenLoadDeviceTable(table, device, vkGetDeviceProcAddrStub);
+}
+
+static void volkGenLoadLoader(void* context, PFN_vkVoidFunction (*load)(void*, const char*))
+{
+ /* VOLK_GENERATE_LOAD_LOADER */
+#if defined(VK_VERSION_1_0)
+ vkCreateInstance = (PFN_vkCreateInstance)load(context, "vkCreateInstance");
+ vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)load(context, "vkEnumerateInstanceExtensionProperties");
+ vkEnumerateInstanceLayerProperties = (PFN_vkEnumerateInstanceLayerProperties)load(context, "vkEnumerateInstanceLayerProperties");
+#endif /* defined(VK_VERSION_1_0) */
+#if defined(VK_VERSION_1_1)
+ vkEnumerateInstanceVersion = (PFN_vkEnumerateInstanceVersion)load(context, "vkEnumerateInstanceVersion");
+#endif /* defined(VK_VERSION_1_1) */
+ /* VOLK_GENERATE_LOAD_LOADER */
+}
+
+static void volkGenLoadInstance(void* context, PFN_vkVoidFunction (*load)(void*, const char*))
+{
+ /* VOLK_GENERATE_LOAD_INSTANCE */
+#if defined(VK_VERSION_1_0)
+ vkCreateDevice = (PFN_vkCreateDevice)load(context, "vkCreateDevice");
+ vkDestroyInstance = (PFN_vkDestroyInstance)load(context, "vkDestroyInstance");
+ vkEnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties)load(context, "vkEnumerateDeviceExtensionProperties");
+ vkEnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties)load(context, "vkEnumerateDeviceLayerProperties");
+ vkEnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices)load(context, "vkEnumeratePhysicalDevices");
+ vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)load(context, "vkGetDeviceProcAddr");
+ vkGetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures)load(context, "vkGetPhysicalDeviceFeatures");
+ vkGetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties)load(context, "vkGetPhysicalDeviceFormatProperties");
+ vkGetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties)load(context, "vkGetPhysicalDeviceImageFormatProperties");
+ vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)load(context, "vkGetPhysicalDeviceMemoryProperties");
+ vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)load(context, "vkGetPhysicalDeviceProperties");
+ vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties)load(context, "vkGetPhysicalDeviceQueueFamilyProperties");
+ vkGetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties)load(context, "vkGetPhysicalDeviceSparseImageFormatProperties");
+#endif /* defined(VK_VERSION_1_0) */
+#if defined(VK_VERSION_1_1)
+ vkEnumeratePhysicalDeviceGroups = (PFN_vkEnumeratePhysicalDeviceGroups)load(context, "vkEnumeratePhysicalDeviceGroups");
+ vkGetPhysicalDeviceExternalBufferProperties = (PFN_vkGetPhysicalDeviceExternalBufferProperties)load(context, "vkGetPhysicalDeviceExternalBufferProperties");
+ vkGetPhysicalDeviceExternalFenceProperties = (PFN_vkGetPhysicalDeviceExternalFenceProperties)load(context, "vkGetPhysicalDeviceExternalFenceProperties");
+ vkGetPhysicalDeviceExternalSemaphoreProperties = (PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)load(context, "vkGetPhysicalDeviceExternalSemaphoreProperties");
+ vkGetPhysicalDeviceFeatures2 = (PFN_vkGetPhysicalDeviceFeatures2)load(context, "vkGetPhysicalDeviceFeatures2");
+ vkGetPhysicalDeviceFormatProperties2 = (PFN_vkGetPhysicalDeviceFormatProperties2)load(context, "vkGetPhysicalDeviceFormatProperties2");
+ vkGetPhysicalDeviceImageFormatProperties2 = (PFN_vkGetPhysicalDeviceImageFormatProperties2)load(context, "vkGetPhysicalDeviceImageFormatProperties2");
+ vkGetPhysicalDeviceMemoryProperties2 = (PFN_vkGetPhysicalDeviceMemoryProperties2)load(context, "vkGetPhysicalDeviceMemoryProperties2");
+ vkGetPhysicalDeviceProperties2 = (PFN_vkGetPhysicalDeviceProperties2)load(context, "vkGetPhysicalDeviceProperties2");
+ vkGetPhysicalDeviceQueueFamilyProperties2 = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2)load(context, "vkGetPhysicalDeviceQueueFamilyProperties2");
+ vkGetPhysicalDeviceSparseImageFormatProperties2 = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)load(context, "vkGetPhysicalDeviceSparseImageFormatProperties2");
+#endif /* defined(VK_VERSION_1_1) */
+#if defined(VK_EXT_acquire_xlib_display)
+ vkAcquireXlibDisplayEXT = (PFN_vkAcquireXlibDisplayEXT)load(context, "vkAcquireXlibDisplayEXT");
+ vkGetRandROutputDisplayEXT = (PFN_vkGetRandROutputDisplayEXT)load(context, "vkGetRandROutputDisplayEXT");
+#endif /* defined(VK_EXT_acquire_xlib_display) */
+#if defined(VK_EXT_calibrated_timestamps)
+ vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = (PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)load(context, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT");
+#endif /* defined(VK_EXT_calibrated_timestamps) */
+#if defined(VK_EXT_debug_report)
+ vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)load(context, "vkCreateDebugReportCallbackEXT");
+ vkDebugReportMessageEXT = (PFN_vkDebugReportMessageEXT)load(context, "vkDebugReportMessageEXT");
+ vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)load(context, "vkDestroyDebugReportCallbackEXT");
+#endif /* defined(VK_EXT_debug_report) */
+#if defined(VK_EXT_debug_utils)
+ vkCmdBeginDebugUtilsLabelEXT = (PFN_vkCmdBeginDebugUtilsLabelEXT)load(context, "vkCmdBeginDebugUtilsLabelEXT");
+ vkCmdEndDebugUtilsLabelEXT = (PFN_vkCmdEndDebugUtilsLabelEXT)load(context, "vkCmdEndDebugUtilsLabelEXT");
+ vkCmdInsertDebugUtilsLabelEXT = (PFN_vkCmdInsertDebugUtilsLabelEXT)load(context, "vkCmdInsertDebugUtilsLabelEXT");
+ vkCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)load(context, "vkCreateDebugUtilsMessengerEXT");
+ vkDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT)load(context, "vkDestroyDebugUtilsMessengerEXT");
+ vkQueueBeginDebugUtilsLabelEXT = (PFN_vkQueueBeginDebugUtilsLabelEXT)load(context, "vkQueueBeginDebugUtilsLabelEXT");
+ vkQueueEndDebugUtilsLabelEXT = (PFN_vkQueueEndDebugUtilsLabelEXT)load(context, "vkQueueEndDebugUtilsLabelEXT");
+ vkQueueInsertDebugUtilsLabelEXT = (PFN_vkQueueInsertDebugUtilsLabelEXT)load(context, "vkQueueInsertDebugUtilsLabelEXT");
+ vkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)load(context, "vkSetDebugUtilsObjectNameEXT");
+ vkSetDebugUtilsObjectTagEXT = (PFN_vkSetDebugUtilsObjectTagEXT)load(context, "vkSetDebugUtilsObjectTagEXT");
+ vkSubmitDebugUtilsMessageEXT = (PFN_vkSubmitDebugUtilsMessageEXT)load(context, "vkSubmitDebugUtilsMessageEXT");
+#endif /* defined(VK_EXT_debug_utils) */
+#if defined(VK_EXT_direct_mode_display)
+ vkReleaseDisplayEXT = (PFN_vkReleaseDisplayEXT)load(context, "vkReleaseDisplayEXT");
+#endif /* defined(VK_EXT_direct_mode_display) */
+#if defined(VK_EXT_display_surface_counter)
+ vkGetPhysicalDeviceSurfaceCapabilities2EXT = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)load(context, "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
+#endif /* defined(VK_EXT_display_surface_counter) */
+#if defined(VK_EXT_full_screen_exclusive)
+ vkGetPhysicalDeviceSurfacePresentModes2EXT = (PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)load(context, "vkGetPhysicalDeviceSurfacePresentModes2EXT");
+#endif /* defined(VK_EXT_full_screen_exclusive) */
+#if defined(VK_EXT_headless_surface)
+ vkCreateHeadlessSurfaceEXT = (PFN_vkCreateHeadlessSurfaceEXT)load(context, "vkCreateHeadlessSurfaceEXT");
+#endif /* defined(VK_EXT_headless_surface) */
+#if defined(VK_EXT_metal_surface)
+ vkCreateMetalSurfaceEXT = (PFN_vkCreateMetalSurfaceEXT)load(context, "vkCreateMetalSurfaceEXT");
+#endif /* defined(VK_EXT_metal_surface) */
+#if defined(VK_EXT_sample_locations)
+ vkGetPhysicalDeviceMultisamplePropertiesEXT = (PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)load(context, "vkGetPhysicalDeviceMultisamplePropertiesEXT");
+#endif /* defined(VK_EXT_sample_locations) */
+#if defined(VK_EXT_tooling_info)
+ vkGetPhysicalDeviceToolPropertiesEXT = (PFN_vkGetPhysicalDeviceToolPropertiesEXT)load(context, "vkGetPhysicalDeviceToolPropertiesEXT");
+#endif /* defined(VK_EXT_tooling_info) */
+#if defined(VK_FUCHSIA_imagepipe_surface)
+ vkCreateImagePipeSurfaceFUCHSIA = (PFN_vkCreateImagePipeSurfaceFUCHSIA)load(context, "vkCreateImagePipeSurfaceFUCHSIA");
+#endif /* defined(VK_FUCHSIA_imagepipe_surface) */
+#if defined(VK_GGP_stream_descriptor_surface)
+ vkCreateStreamDescriptorSurfaceGGP = (PFN_vkCreateStreamDescriptorSurfaceGGP)load(context, "vkCreateStreamDescriptorSurfaceGGP");
+#endif /* defined(VK_GGP_stream_descriptor_surface) */
+#if defined(VK_KHR_android_surface)
+ vkCreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR)load(context, "vkCreateAndroidSurfaceKHR");
+#endif /* defined(VK_KHR_android_surface) */
+#if defined(VK_KHR_device_group_creation)
+ vkEnumeratePhysicalDeviceGroupsKHR = (PFN_vkEnumeratePhysicalDeviceGroupsKHR)load(context, "vkEnumeratePhysicalDeviceGroupsKHR");
+#endif /* defined(VK_KHR_device_group_creation) */
+#if defined(VK_KHR_display)
+ vkCreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR)load(context, "vkCreateDisplayModeKHR");
+ vkCreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR)load(context, "vkCreateDisplayPlaneSurfaceKHR");
+ vkGetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR)load(context, "vkGetDisplayModePropertiesKHR");
+ vkGetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR)load(context, "vkGetDisplayPlaneCapabilitiesKHR");
+ vkGetDisplayPlaneSupportedDisplaysKHR = (PFN_vkGetDisplayPlaneSupportedDisplaysKHR)load(context, "vkGetDisplayPlaneSupportedDisplaysKHR");
+ vkGetPhysicalDeviceDisplayPlanePropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)load(context, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
+ vkGetPhysicalDeviceDisplayPropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)load(context, "vkGetPhysicalDeviceDisplayPropertiesKHR");
+#endif /* defined(VK_KHR_display) */
+#if defined(VK_KHR_external_fence_capabilities)
+ vkGetPhysicalDeviceExternalFencePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)load(context, "vkGetPhysicalDeviceExternalFencePropertiesKHR");
+#endif /* defined(VK_KHR_external_fence_capabilities) */
+#if defined(VK_KHR_external_memory_capabilities)
+ vkGetPhysicalDeviceExternalBufferPropertiesKHR = (PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)load(context, "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
+#endif /* defined(VK_KHR_external_memory_capabilities) */
+#if defined(VK_KHR_external_semaphore_capabilities)
+ vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)load(context, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
+#endif /* defined(VK_KHR_external_semaphore_capabilities) */
+#if defined(VK_KHR_get_display_properties2)
+ vkGetDisplayModeProperties2KHR = (PFN_vkGetDisplayModeProperties2KHR)load(context, "vkGetDisplayModeProperties2KHR");
+ vkGetDisplayPlaneCapabilities2KHR = (PFN_vkGetDisplayPlaneCapabilities2KHR)load(context, "vkGetDisplayPlaneCapabilities2KHR");
+ vkGetPhysicalDeviceDisplayPlaneProperties2KHR = (PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)load(context, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR");
+ vkGetPhysicalDeviceDisplayProperties2KHR = (PFN_vkGetPhysicalDeviceDisplayProperties2KHR)load(context, "vkGetPhysicalDeviceDisplayProperties2KHR");
+#endif /* defined(VK_KHR_get_display_properties2) */
+#if defined(VK_KHR_get_physical_device_properties2)
+ vkGetPhysicalDeviceFeatures2KHR = (PFN_vkGetPhysicalDeviceFeatures2KHR)load(context, "vkGetPhysicalDeviceFeatures2KHR");
+ vkGetPhysicalDeviceFormatProperties2KHR = (PFN_vkGetPhysicalDeviceFormatProperties2KHR)load(context, "vkGetPhysicalDeviceFormatProperties2KHR");
+ vkGetPhysicalDeviceImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)load(context, "vkGetPhysicalDeviceImageFormatProperties2KHR");
+ vkGetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)load(context, "vkGetPhysicalDeviceMemoryProperties2KHR");
+ vkGetPhysicalDeviceProperties2KHR = (PFN_vkGetPhysicalDeviceProperties2KHR)load(context, "vkGetPhysicalDeviceProperties2KHR");
+ vkGetPhysicalDeviceQueueFamilyProperties2KHR = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)load(context, "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
+ vkGetPhysicalDeviceSparseImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)load(context, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+#endif /* defined(VK_KHR_get_physical_device_properties2) */
+#if defined(VK_KHR_get_surface_capabilities2)
+ vkGetPhysicalDeviceSurfaceCapabilities2KHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)load(context, "vkGetPhysicalDeviceSurfaceCapabilities2KHR");
+ vkGetPhysicalDeviceSurfaceFormats2KHR = (PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)load(context, "vkGetPhysicalDeviceSurfaceFormats2KHR");
+#endif /* defined(VK_KHR_get_surface_capabilities2) */
+#if defined(VK_KHR_performance_query)
+ vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = (PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)load(context, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
+ vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = (PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)load(context, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
+#endif /* defined(VK_KHR_performance_query) */
+#if defined(VK_KHR_surface)
+ vkDestroySurfaceKHR = (PFN_vkDestroySurfaceKHR)load(context, "vkDestroySurfaceKHR");
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)load(context, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+ vkGetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)load(context, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+ vkGetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)load(context, "vkGetPhysicalDeviceSurfacePresentModesKHR");
+ vkGetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)load(context, "vkGetPhysicalDeviceSurfaceSupportKHR");
+#endif /* defined(VK_KHR_surface) */
+#if defined(VK_KHR_wayland_surface)
+ vkCreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR)load(context, "vkCreateWaylandSurfaceKHR");
+ vkGetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)load(context, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
+#endif /* defined(VK_KHR_wayland_surface) */
+#if defined(VK_KHR_win32_surface)
+ vkCreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR)load(context, "vkCreateWin32SurfaceKHR");
+ vkGetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)load(context, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
+#endif /* defined(VK_KHR_win32_surface) */
+#if defined(VK_KHR_xcb_surface)
+ vkCreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR)load(context, "vkCreateXcbSurfaceKHR");
+ vkGetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)load(context, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
+#endif /* defined(VK_KHR_xcb_surface) */
+#if defined(VK_KHR_xlib_surface)
+ vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR)load(context, "vkCreateXlibSurfaceKHR");
+ vkGetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)load(context, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
+#endif /* defined(VK_KHR_xlib_surface) */
+#if defined(VK_MVK_ios_surface)
+ vkCreateIOSSurfaceMVK = (PFN_vkCreateIOSSurfaceMVK)load(context, "vkCreateIOSSurfaceMVK");
+#endif /* defined(VK_MVK_ios_surface) */
+#if defined(VK_MVK_macos_surface)
+ vkCreateMacOSSurfaceMVK = (PFN_vkCreateMacOSSurfaceMVK)load(context, "vkCreateMacOSSurfaceMVK");
+#endif /* defined(VK_MVK_macos_surface) */
+#if defined(VK_NN_vi_surface)
+ vkCreateViSurfaceNN = (PFN_vkCreateViSurfaceNN)load(context, "vkCreateViSurfaceNN");
+#endif /* defined(VK_NN_vi_surface) */
+#if defined(VK_NVX_device_generated_commands)
+ vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)load(context, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
+#endif /* defined(VK_NVX_device_generated_commands) */
+#if defined(VK_NV_cooperative_matrix)
+ vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)load(context, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV");
+#endif /* defined(VK_NV_cooperative_matrix) */
+#if defined(VK_NV_coverage_reduction_mode)
+ vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = (PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)load(context, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV");
+#endif /* defined(VK_NV_coverage_reduction_mode) */
+#if defined(VK_NV_external_memory_capabilities)
+ vkGetPhysicalDeviceExternalImageFormatPropertiesNV = (PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)load(context, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
+#endif /* defined(VK_NV_external_memory_capabilities) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+ vkGetPhysicalDevicePresentRectanglesKHR = (PFN_vkGetPhysicalDevicePresentRectanglesKHR)load(context, "vkGetPhysicalDevicePresentRectanglesKHR");
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+ /* VOLK_GENERATE_LOAD_INSTANCE */
+}
+
+static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, const char*))
+{
+ /* VOLK_GENERATE_LOAD_DEVICE */
+#if defined(VK_VERSION_1_0)
+ vkAllocateCommandBuffers = (PFN_vkAllocateCommandBuffers)load(context, "vkAllocateCommandBuffers");
+ vkAllocateDescriptorSets = (PFN_vkAllocateDescriptorSets)load(context, "vkAllocateDescriptorSets");
+ vkAllocateMemory = (PFN_vkAllocateMemory)load(context, "vkAllocateMemory");
+ vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer)load(context, "vkBeginCommandBuffer");
+ vkBindBufferMemory = (PFN_vkBindBufferMemory)load(context, "vkBindBufferMemory");
+ vkBindImageMemory = (PFN_vkBindImageMemory)load(context, "vkBindImageMemory");
+ vkCmdBeginQuery = (PFN_vkCmdBeginQuery)load(context, "vkCmdBeginQuery");
+ vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)load(context, "vkCmdBeginRenderPass");
+ vkCmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets)load(context, "vkCmdBindDescriptorSets");
+ vkCmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer)load(context, "vkCmdBindIndexBuffer");
+ vkCmdBindPipeline = (PFN_vkCmdBindPipeline)load(context, "vkCmdBindPipeline");
+ vkCmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers)load(context, "vkCmdBindVertexBuffers");
+ vkCmdBlitImage = (PFN_vkCmdBlitImage)load(context, "vkCmdBlitImage");
+ vkCmdClearAttachments = (PFN_vkCmdClearAttachments)load(context, "vkCmdClearAttachments");
+ vkCmdClearColorImage = (PFN_vkCmdClearColorImage)load(context, "vkCmdClearColorImage");
+ vkCmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage)load(context, "vkCmdClearDepthStencilImage");
+ vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)load(context, "vkCmdCopyBuffer");
+ vkCmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage)load(context, "vkCmdCopyBufferToImage");
+ vkCmdCopyImage = (PFN_vkCmdCopyImage)load(context, "vkCmdCopyImage");
+ vkCmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer)load(context, "vkCmdCopyImageToBuffer");
+ vkCmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults)load(context, "vkCmdCopyQueryPoolResults");
+ vkCmdDispatch = (PFN_vkCmdDispatch)load(context, "vkCmdDispatch");
+ vkCmdDispatchIndirect = (PFN_vkCmdDispatchIndirect)load(context, "vkCmdDispatchIndirect");
+ vkCmdDraw = (PFN_vkCmdDraw)load(context, "vkCmdDraw");
+ vkCmdDrawIndexed = (PFN_vkCmdDrawIndexed)load(context, "vkCmdDrawIndexed");
+ vkCmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect)load(context, "vkCmdDrawIndexedIndirect");
+ vkCmdDrawIndirect = (PFN_vkCmdDrawIndirect)load(context, "vkCmdDrawIndirect");
+ vkCmdEndQuery = (PFN_vkCmdEndQuery)load(context, "vkCmdEndQuery");
+ vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass)load(context, "vkCmdEndRenderPass");
+ vkCmdExecuteCommands = (PFN_vkCmdExecuteCommands)load(context, "vkCmdExecuteCommands");
+ vkCmdFillBuffer = (PFN_vkCmdFillBuffer)load(context, "vkCmdFillBuffer");
+ vkCmdNextSubpass = (PFN_vkCmdNextSubpass)load(context, "vkCmdNextSubpass");
+ vkCmdPipelineBarrier = (PFN_vkCmdPipelineBarrier)load(context, "vkCmdPipelineBarrier");
+ vkCmdPushConstants = (PFN_vkCmdPushConstants)load(context, "vkCmdPushConstants");
+ vkCmdResetEvent = (PFN_vkCmdResetEvent)load(context, "vkCmdResetEvent");
+ vkCmdResetQueryPool = (PFN_vkCmdResetQueryPool)load(context, "vkCmdResetQueryPool");
+ vkCmdResolveImage = (PFN_vkCmdResolveImage)load(context, "vkCmdResolveImage");
+ vkCmdSetBlendConstants = (PFN_vkCmdSetBlendConstants)load(context, "vkCmdSetBlendConstants");
+ vkCmdSetDepthBias = (PFN_vkCmdSetDepthBias)load(context, "vkCmdSetDepthBias");
+ vkCmdSetDepthBounds = (PFN_vkCmdSetDepthBounds)load(context, "vkCmdSetDepthBounds");
+ vkCmdSetEvent = (PFN_vkCmdSetEvent)load(context, "vkCmdSetEvent");
+ vkCmdSetLineWidth = (PFN_vkCmdSetLineWidth)load(context, "vkCmdSetLineWidth");
+ vkCmdSetScissor = (PFN_vkCmdSetScissor)load(context, "vkCmdSetScissor");
+ vkCmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask)load(context, "vkCmdSetStencilCompareMask");
+ vkCmdSetStencilReference = (PFN_vkCmdSetStencilReference)load(context, "vkCmdSetStencilReference");
+ vkCmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask)load(context, "vkCmdSetStencilWriteMask");
+ vkCmdSetViewport = (PFN_vkCmdSetViewport)load(context, "vkCmdSetViewport");
+ vkCmdUpdateBuffer = (PFN_vkCmdUpdateBuffer)load(context, "vkCmdUpdateBuffer");
+ vkCmdWaitEvents = (PFN_vkCmdWaitEvents)load(context, "vkCmdWaitEvents");
+ vkCmdWriteTimestamp = (PFN_vkCmdWriteTimestamp)load(context, "vkCmdWriteTimestamp");
+ vkCreateBuffer = (PFN_vkCreateBuffer)load(context, "vkCreateBuffer");
+ vkCreateBufferView = (PFN_vkCreateBufferView)load(context, "vkCreateBufferView");
+ vkCreateCommandPool = (PFN_vkCreateCommandPool)load(context, "vkCreateCommandPool");
+ vkCreateComputePipelines = (PFN_vkCreateComputePipelines)load(context, "vkCreateComputePipelines");
+ vkCreateDescriptorPool = (PFN_vkCreateDescriptorPool)load(context, "vkCreateDescriptorPool");
+ vkCreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout)load(context, "vkCreateDescriptorSetLayout");
+ vkCreateEvent = (PFN_vkCreateEvent)load(context, "vkCreateEvent");
+ vkCreateFence = (PFN_vkCreateFence)load(context, "vkCreateFence");
+ vkCreateFramebuffer = (PFN_vkCreateFramebuffer)load(context, "vkCreateFramebuffer");
+ vkCreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines)load(context, "vkCreateGraphicsPipelines");
+ vkCreateImage = (PFN_vkCreateImage)load(context, "vkCreateImage");
+ vkCreateImageView = (PFN_vkCreateImageView)load(context, "vkCreateImageView");
+ vkCreatePipelineCache = (PFN_vkCreatePipelineCache)load(context, "vkCreatePipelineCache");
+ vkCreatePipelineLayout = (PFN_vkCreatePipelineLayout)load(context, "vkCreatePipelineLayout");
+ vkCreateQueryPool = (PFN_vkCreateQueryPool)load(context, "vkCreateQueryPool");
+ vkCreateRenderPass = (PFN_vkCreateRenderPass)load(context, "vkCreateRenderPass");
+ vkCreateSampler = (PFN_vkCreateSampler)load(context, "vkCreateSampler");
+ vkCreateSemaphore = (PFN_vkCreateSemaphore)load(context, "vkCreateSemaphore");
+ vkCreateShaderModule = (PFN_vkCreateShaderModule)load(context, "vkCreateShaderModule");
+ vkDestroyBuffer = (PFN_vkDestroyBuffer)load(context, "vkDestroyBuffer");
+ vkDestroyBufferView = (PFN_vkDestroyBufferView)load(context, "vkDestroyBufferView");
+ vkDestroyCommandPool = (PFN_vkDestroyCommandPool)load(context, "vkDestroyCommandPool");
+ vkDestroyDescriptorPool = (PFN_vkDestroyDescriptorPool)load(context, "vkDestroyDescriptorPool");
+ vkDestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout)load(context, "vkDestroyDescriptorSetLayout");
+ vkDestroyDevice = (PFN_vkDestroyDevice)load(context, "vkDestroyDevice");
+ vkDestroyEvent = (PFN_vkDestroyEvent)load(context, "vkDestroyEvent");
+ vkDestroyFence = (PFN_vkDestroyFence)load(context, "vkDestroyFence");
+ vkDestroyFramebuffer = (PFN_vkDestroyFramebuffer)load(context, "vkDestroyFramebuffer");
+ vkDestroyImage = (PFN_vkDestroyImage)load(context, "vkDestroyImage");
+ vkDestroyImageView = (PFN_vkDestroyImageView)load(context, "vkDestroyImageView");
+ vkDestroyPipeline = (PFN_vkDestroyPipeline)load(context, "vkDestroyPipeline");
+ vkDestroyPipelineCache = (PFN_vkDestroyPipelineCache)load(context, "vkDestroyPipelineCache");
+ vkDestroyPipelineLayout = (PFN_vkDestroyPipelineLayout)load(context, "vkDestroyPipelineLayout");
+ vkDestroyQueryPool = (PFN_vkDestroyQueryPool)load(context, "vkDestroyQueryPool");
+ vkDestroyRenderPass = (PFN_vkDestroyRenderPass)load(context, "vkDestroyRenderPass");
+ vkDestroySampler = (PFN_vkDestroySampler)load(context, "vkDestroySampler");
+ vkDestroySemaphore = (PFN_vkDestroySemaphore)load(context, "vkDestroySemaphore");
+ vkDestroyShaderModule = (PFN_vkDestroyShaderModule)load(context, "vkDestroyShaderModule");
+ vkDeviceWaitIdle = (PFN_vkDeviceWaitIdle)load(context, "vkDeviceWaitIdle");
+ vkEndCommandBuffer = (PFN_vkEndCommandBuffer)load(context, "vkEndCommandBuffer");
+ vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)load(context, "vkFlushMappedMemoryRanges");
+ vkFreeCommandBuffers = (PFN_vkFreeCommandBuffers)load(context, "vkFreeCommandBuffers");
+ vkFreeDescriptorSets = (PFN_vkFreeDescriptorSets)load(context, "vkFreeDescriptorSets");
+ vkFreeMemory = (PFN_vkFreeMemory)load(context, "vkFreeMemory");
+ vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)load(context, "vkGetBufferMemoryRequirements");
+ vkGetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment)load(context, "vkGetDeviceMemoryCommitment");
+ vkGetDeviceQueue = (PFN_vkGetDeviceQueue)load(context, "vkGetDeviceQueue");
+ vkGetEventStatus = (PFN_vkGetEventStatus)load(context, "vkGetEventStatus");
+ vkGetFenceStatus = (PFN_vkGetFenceStatus)load(context, "vkGetFenceStatus");
+ vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)load(context, "vkGetImageMemoryRequirements");
+ vkGetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements)load(context, "vkGetImageSparseMemoryRequirements");
+ vkGetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout)load(context, "vkGetImageSubresourceLayout");
+ vkGetPipelineCacheData = (PFN_vkGetPipelineCacheData)load(context, "vkGetPipelineCacheData");
+ vkGetQueryPoolResults = (PFN_vkGetQueryPoolResults)load(context, "vkGetQueryPoolResults");
+ vkGetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity)load(context, "vkGetRenderAreaGranularity");
+ vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)load(context, "vkInvalidateMappedMemoryRanges");
+ vkMapMemory = (PFN_vkMapMemory)load(context, "vkMapMemory");
+ vkMergePipelineCaches = (PFN_vkMergePipelineCaches)load(context, "vkMergePipelineCaches");
+ vkQueueBindSparse = (PFN_vkQueueBindSparse)load(context, "vkQueueBindSparse");
+ vkQueueSubmit = (PFN_vkQueueSubmit)load(context, "vkQueueSubmit");
+ vkQueueWaitIdle = (PFN_vkQueueWaitIdle)load(context, "vkQueueWaitIdle");
+ vkResetCommandBuffer = (PFN_vkResetCommandBuffer)load(context, "vkResetCommandBuffer");
+ vkResetCommandPool = (PFN_vkResetCommandPool)load(context, "vkResetCommandPool");
+ vkResetDescriptorPool = (PFN_vkResetDescriptorPool)load(context, "vkResetDescriptorPool");
+ vkResetEvent = (PFN_vkResetEvent)load(context, "vkResetEvent");
+ vkResetFences = (PFN_vkResetFences)load(context, "vkResetFences");
+ vkSetEvent = (PFN_vkSetEvent)load(context, "vkSetEvent");
+ vkUnmapMemory = (PFN_vkUnmapMemory)load(context, "vkUnmapMemory");
+ vkUpdateDescriptorSets = (PFN_vkUpdateDescriptorSets)load(context, "vkUpdateDescriptorSets");
+ vkWaitForFences = (PFN_vkWaitForFences)load(context, "vkWaitForFences");
+#endif /* defined(VK_VERSION_1_0) */
+#if defined(VK_VERSION_1_1)
+ vkBindBufferMemory2 = (PFN_vkBindBufferMemory2)load(context, "vkBindBufferMemory2");
+ vkBindImageMemory2 = (PFN_vkBindImageMemory2)load(context, "vkBindImageMemory2");
+ vkCmdDispatchBase = (PFN_vkCmdDispatchBase)load(context, "vkCmdDispatchBase");
+ vkCmdSetDeviceMask = (PFN_vkCmdSetDeviceMask)load(context, "vkCmdSetDeviceMask");
+ vkCreateDescriptorUpdateTemplate = (PFN_vkCreateDescriptorUpdateTemplate)load(context, "vkCreateDescriptorUpdateTemplate");
+ vkCreateSamplerYcbcrConversion = (PFN_vkCreateSamplerYcbcrConversion)load(context, "vkCreateSamplerYcbcrConversion");
+ vkDestroyDescriptorUpdateTemplate = (PFN_vkDestroyDescriptorUpdateTemplate)load(context, "vkDestroyDescriptorUpdateTemplate");
+ vkDestroySamplerYcbcrConversion = (PFN_vkDestroySamplerYcbcrConversion)load(context, "vkDestroySamplerYcbcrConversion");
+ vkGetBufferMemoryRequirements2 = (PFN_vkGetBufferMemoryRequirements2)load(context, "vkGetBufferMemoryRequirements2");
+ vkGetDescriptorSetLayoutSupport = (PFN_vkGetDescriptorSetLayoutSupport)load(context, "vkGetDescriptorSetLayoutSupport");
+ vkGetDeviceGroupPeerMemoryFeatures = (PFN_vkGetDeviceGroupPeerMemoryFeatures)load(context, "vkGetDeviceGroupPeerMemoryFeatures");
+ vkGetDeviceQueue2 = (PFN_vkGetDeviceQueue2)load(context, "vkGetDeviceQueue2");
+ vkGetImageMemoryRequirements2 = (PFN_vkGetImageMemoryRequirements2)load(context, "vkGetImageMemoryRequirements2");
+ vkGetImageSparseMemoryRequirements2 = (PFN_vkGetImageSparseMemoryRequirements2)load(context, "vkGetImageSparseMemoryRequirements2");
+ vkTrimCommandPool = (PFN_vkTrimCommandPool)load(context, "vkTrimCommandPool");
+ vkUpdateDescriptorSetWithTemplate = (PFN_vkUpdateDescriptorSetWithTemplate)load(context, "vkUpdateDescriptorSetWithTemplate");
+#endif /* defined(VK_VERSION_1_1) */
+#if defined(VK_VERSION_1_2)
+ vkCmdBeginRenderPass2 = (PFN_vkCmdBeginRenderPass2)load(context, "vkCmdBeginRenderPass2");
+ vkCmdDrawIndexedIndirectCount = (PFN_vkCmdDrawIndexedIndirectCount)load(context, "vkCmdDrawIndexedIndirectCount");
+ vkCmdDrawIndirectCount = (PFN_vkCmdDrawIndirectCount)load(context, "vkCmdDrawIndirectCount");
+ vkCmdEndRenderPass2 = (PFN_vkCmdEndRenderPass2)load(context, "vkCmdEndRenderPass2");
+ vkCmdNextSubpass2 = (PFN_vkCmdNextSubpass2)load(context, "vkCmdNextSubpass2");
+ vkCreateRenderPass2 = (PFN_vkCreateRenderPass2)load(context, "vkCreateRenderPass2");
+ vkGetBufferDeviceAddress = (PFN_vkGetBufferDeviceAddress)load(context, "vkGetBufferDeviceAddress");
+ vkGetBufferOpaqueCaptureAddress = (PFN_vkGetBufferOpaqueCaptureAddress)load(context, "vkGetBufferOpaqueCaptureAddress");
+ vkGetDeviceMemoryOpaqueCaptureAddress = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)load(context, "vkGetDeviceMemoryOpaqueCaptureAddress");
+ vkGetSemaphoreCounterValue = (PFN_vkGetSemaphoreCounterValue)load(context, "vkGetSemaphoreCounterValue");
+ vkResetQueryPool = (PFN_vkResetQueryPool)load(context, "vkResetQueryPool");
+ vkSignalSemaphore = (PFN_vkSignalSemaphore)load(context, "vkSignalSemaphore");
+ vkWaitSemaphores = (PFN_vkWaitSemaphores)load(context, "vkWaitSemaphores");
+#endif /* defined(VK_VERSION_1_2) */
+#if defined(VK_AMD_buffer_marker)
+ vkCmdWriteBufferMarkerAMD = (PFN_vkCmdWriteBufferMarkerAMD)load(context, "vkCmdWriteBufferMarkerAMD");
+#endif /* defined(VK_AMD_buffer_marker) */
+#if defined(VK_AMD_display_native_hdr)
+ vkSetLocalDimmingAMD = (PFN_vkSetLocalDimmingAMD)load(context, "vkSetLocalDimmingAMD");
+#endif /* defined(VK_AMD_display_native_hdr) */
+#if defined(VK_AMD_draw_indirect_count)
+ vkCmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)load(context, "vkCmdDrawIndexedIndirectCountAMD");
+ vkCmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)load(context, "vkCmdDrawIndirectCountAMD");
+#endif /* defined(VK_AMD_draw_indirect_count) */
+#if defined(VK_AMD_shader_info)
+ vkGetShaderInfoAMD = (PFN_vkGetShaderInfoAMD)load(context, "vkGetShaderInfoAMD");
+#endif /* defined(VK_AMD_shader_info) */
+#if defined(VK_ANDROID_external_memory_android_hardware_buffer)
+ vkGetAndroidHardwareBufferPropertiesANDROID = (PFN_vkGetAndroidHardwareBufferPropertiesANDROID)load(context, "vkGetAndroidHardwareBufferPropertiesANDROID");
+ vkGetMemoryAndroidHardwareBufferANDROID = (PFN_vkGetMemoryAndroidHardwareBufferANDROID)load(context, "vkGetMemoryAndroidHardwareBufferANDROID");
+#endif /* defined(VK_ANDROID_external_memory_android_hardware_buffer) */
+#if defined(VK_EXT_buffer_device_address)
+ vkGetBufferDeviceAddressEXT = (PFN_vkGetBufferDeviceAddressEXT)load(context, "vkGetBufferDeviceAddressEXT");
+#endif /* defined(VK_EXT_buffer_device_address) */
+#if defined(VK_EXT_calibrated_timestamps)
+ vkGetCalibratedTimestampsEXT = (PFN_vkGetCalibratedTimestampsEXT)load(context, "vkGetCalibratedTimestampsEXT");
+#endif /* defined(VK_EXT_calibrated_timestamps) */
+#if defined(VK_EXT_conditional_rendering)
+ vkCmdBeginConditionalRenderingEXT = (PFN_vkCmdBeginConditionalRenderingEXT)load(context, "vkCmdBeginConditionalRenderingEXT");
+ vkCmdEndConditionalRenderingEXT = (PFN_vkCmdEndConditionalRenderingEXT)load(context, "vkCmdEndConditionalRenderingEXT");
+#endif /* defined(VK_EXT_conditional_rendering) */
+#if defined(VK_EXT_debug_marker)
+ vkCmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT)load(context, "vkCmdDebugMarkerBeginEXT");
+ vkCmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT)load(context, "vkCmdDebugMarkerEndEXT");
+ vkCmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT)load(context, "vkCmdDebugMarkerInsertEXT");
+ vkDebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)load(context, "vkDebugMarkerSetObjectNameEXT");
+ vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)load(context, "vkDebugMarkerSetObjectTagEXT");
+#endif /* defined(VK_EXT_debug_marker) */
+#if defined(VK_EXT_discard_rectangles)
+ vkCmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)load(context, "vkCmdSetDiscardRectangleEXT");
+#endif /* defined(VK_EXT_discard_rectangles) */
+#if defined(VK_EXT_display_control)
+ vkDisplayPowerControlEXT = (PFN_vkDisplayPowerControlEXT)load(context, "vkDisplayPowerControlEXT");
+ vkGetSwapchainCounterEXT = (PFN_vkGetSwapchainCounterEXT)load(context, "vkGetSwapchainCounterEXT");
+ vkRegisterDeviceEventEXT = (PFN_vkRegisterDeviceEventEXT)load(context, "vkRegisterDeviceEventEXT");
+ vkRegisterDisplayEventEXT = (PFN_vkRegisterDisplayEventEXT)load(context, "vkRegisterDisplayEventEXT");
+#endif /* defined(VK_EXT_display_control) */
+#if defined(VK_EXT_external_memory_host)
+ vkGetMemoryHostPointerPropertiesEXT = (PFN_vkGetMemoryHostPointerPropertiesEXT)load(context, "vkGetMemoryHostPointerPropertiesEXT");
+#endif /* defined(VK_EXT_external_memory_host) */
+#if defined(VK_EXT_full_screen_exclusive)
+ vkAcquireFullScreenExclusiveModeEXT = (PFN_vkAcquireFullScreenExclusiveModeEXT)load(context, "vkAcquireFullScreenExclusiveModeEXT");
+ vkReleaseFullScreenExclusiveModeEXT = (PFN_vkReleaseFullScreenExclusiveModeEXT)load(context, "vkReleaseFullScreenExclusiveModeEXT");
+#endif /* defined(VK_EXT_full_screen_exclusive) */
+#if defined(VK_EXT_hdr_metadata)
+ vkSetHdrMetadataEXT = (PFN_vkSetHdrMetadataEXT)load(context, "vkSetHdrMetadataEXT");
+#endif /* defined(VK_EXT_hdr_metadata) */
+#if defined(VK_EXT_host_query_reset)
+ vkResetQueryPoolEXT = (PFN_vkResetQueryPoolEXT)load(context, "vkResetQueryPoolEXT");
+#endif /* defined(VK_EXT_host_query_reset) */
+#if defined(VK_EXT_image_drm_format_modifier)
+ vkGetImageDrmFormatModifierPropertiesEXT = (PFN_vkGetImageDrmFormatModifierPropertiesEXT)load(context, "vkGetImageDrmFormatModifierPropertiesEXT");
+#endif /* defined(VK_EXT_image_drm_format_modifier) */
+#if defined(VK_EXT_line_rasterization)
+ vkCmdSetLineStippleEXT = (PFN_vkCmdSetLineStippleEXT)load(context, "vkCmdSetLineStippleEXT");
+#endif /* defined(VK_EXT_line_rasterization) */
+#if defined(VK_EXT_sample_locations)
+ vkCmdSetSampleLocationsEXT = (PFN_vkCmdSetSampleLocationsEXT)load(context, "vkCmdSetSampleLocationsEXT");
+#endif /* defined(VK_EXT_sample_locations) */
+#if defined(VK_EXT_transform_feedback)
+ vkCmdBeginQueryIndexedEXT = (PFN_vkCmdBeginQueryIndexedEXT)load(context, "vkCmdBeginQueryIndexedEXT");
+ vkCmdBeginTransformFeedbackEXT = (PFN_vkCmdBeginTransformFeedbackEXT)load(context, "vkCmdBeginTransformFeedbackEXT");
+ vkCmdBindTransformFeedbackBuffersEXT = (PFN_vkCmdBindTransformFeedbackBuffersEXT)load(context, "vkCmdBindTransformFeedbackBuffersEXT");
+ vkCmdDrawIndirectByteCountEXT = (PFN_vkCmdDrawIndirectByteCountEXT)load(context, "vkCmdDrawIndirectByteCountEXT");
+ vkCmdEndQueryIndexedEXT = (PFN_vkCmdEndQueryIndexedEXT)load(context, "vkCmdEndQueryIndexedEXT");
+ vkCmdEndTransformFeedbackEXT = (PFN_vkCmdEndTransformFeedbackEXT)load(context, "vkCmdEndTransformFeedbackEXT");
+#endif /* defined(VK_EXT_transform_feedback) */
+#if defined(VK_EXT_validation_cache)
+ vkCreateValidationCacheEXT = (PFN_vkCreateValidationCacheEXT)load(context, "vkCreateValidationCacheEXT");
+ vkDestroyValidationCacheEXT = (PFN_vkDestroyValidationCacheEXT)load(context, "vkDestroyValidationCacheEXT");
+ vkGetValidationCacheDataEXT = (PFN_vkGetValidationCacheDataEXT)load(context, "vkGetValidationCacheDataEXT");
+ vkMergeValidationCachesEXT = (PFN_vkMergeValidationCachesEXT)load(context, "vkMergeValidationCachesEXT");
+#endif /* defined(VK_EXT_validation_cache) */
+#if defined(VK_GOOGLE_display_timing)
+ vkGetPastPresentationTimingGOOGLE = (PFN_vkGetPastPresentationTimingGOOGLE)load(context, "vkGetPastPresentationTimingGOOGLE");
+ vkGetRefreshCycleDurationGOOGLE = (PFN_vkGetRefreshCycleDurationGOOGLE)load(context, "vkGetRefreshCycleDurationGOOGLE");
+#endif /* defined(VK_GOOGLE_display_timing) */
+#if defined(VK_INTEL_performance_query)
+ vkAcquirePerformanceConfigurationINTEL = (PFN_vkAcquirePerformanceConfigurationINTEL)load(context, "vkAcquirePerformanceConfigurationINTEL");
+ vkCmdSetPerformanceMarkerINTEL = (PFN_vkCmdSetPerformanceMarkerINTEL)load(context, "vkCmdSetPerformanceMarkerINTEL");
+ vkCmdSetPerformanceOverrideINTEL = (PFN_vkCmdSetPerformanceOverrideINTEL)load(context, "vkCmdSetPerformanceOverrideINTEL");
+ vkCmdSetPerformanceStreamMarkerINTEL = (PFN_vkCmdSetPerformanceStreamMarkerINTEL)load(context, "vkCmdSetPerformanceStreamMarkerINTEL");
+ vkGetPerformanceParameterINTEL = (PFN_vkGetPerformanceParameterINTEL)load(context, "vkGetPerformanceParameterINTEL");
+ vkInitializePerformanceApiINTEL = (PFN_vkInitializePerformanceApiINTEL)load(context, "vkInitializePerformanceApiINTEL");
+ vkQueueSetPerformanceConfigurationINTEL = (PFN_vkQueueSetPerformanceConfigurationINTEL)load(context, "vkQueueSetPerformanceConfigurationINTEL");
+ vkReleasePerformanceConfigurationINTEL = (PFN_vkReleasePerformanceConfigurationINTEL)load(context, "vkReleasePerformanceConfigurationINTEL");
+ vkUninitializePerformanceApiINTEL = (PFN_vkUninitializePerformanceApiINTEL)load(context, "vkUninitializePerformanceApiINTEL");
+#endif /* defined(VK_INTEL_performance_query) */
+#if defined(VK_KHR_bind_memory2)
+ vkBindBufferMemory2KHR = (PFN_vkBindBufferMemory2KHR)load(context, "vkBindBufferMemory2KHR");
+ vkBindImageMemory2KHR = (PFN_vkBindImageMemory2KHR)load(context, "vkBindImageMemory2KHR");
+#endif /* defined(VK_KHR_bind_memory2) */
+#if defined(VK_KHR_buffer_device_address)
+ vkGetBufferDeviceAddressKHR = (PFN_vkGetBufferDeviceAddressKHR)load(context, "vkGetBufferDeviceAddressKHR");
+ vkGetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)load(context, "vkGetBufferOpaqueCaptureAddressKHR");
+ vkGetDeviceMemoryOpaqueCaptureAddressKHR = (PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)load(context, "vkGetDeviceMemoryOpaqueCaptureAddressKHR");
+#endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_create_renderpass2)
+ vkCmdBeginRenderPass2KHR = (PFN_vkCmdBeginRenderPass2KHR)load(context, "vkCmdBeginRenderPass2KHR");
+ vkCmdEndRenderPass2KHR = (PFN_vkCmdEndRenderPass2KHR)load(context, "vkCmdEndRenderPass2KHR");
+ vkCmdNextSubpass2KHR = (PFN_vkCmdNextSubpass2KHR)load(context, "vkCmdNextSubpass2KHR");
+ vkCreateRenderPass2KHR = (PFN_vkCreateRenderPass2KHR)load(context, "vkCreateRenderPass2KHR");
+#endif /* defined(VK_KHR_create_renderpass2) */
+#if defined(VK_KHR_descriptor_update_template)
+ vkCreateDescriptorUpdateTemplateKHR = (PFN_vkCreateDescriptorUpdateTemplateKHR)load(context, "vkCreateDescriptorUpdateTemplateKHR");
+ vkDestroyDescriptorUpdateTemplateKHR = (PFN_vkDestroyDescriptorUpdateTemplateKHR)load(context, "vkDestroyDescriptorUpdateTemplateKHR");
+ vkUpdateDescriptorSetWithTemplateKHR = (PFN_vkUpdateDescriptorSetWithTemplateKHR)load(context, "vkUpdateDescriptorSetWithTemplateKHR");
+#endif /* defined(VK_KHR_descriptor_update_template) */
+#if defined(VK_KHR_device_group)
+ vkCmdDispatchBaseKHR = (PFN_vkCmdDispatchBaseKHR)load(context, "vkCmdDispatchBaseKHR");
+ vkCmdSetDeviceMaskKHR = (PFN_vkCmdSetDeviceMaskKHR)load(context, "vkCmdSetDeviceMaskKHR");
+ vkGetDeviceGroupPeerMemoryFeaturesKHR = (PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)load(context, "vkGetDeviceGroupPeerMemoryFeaturesKHR");
+#endif /* defined(VK_KHR_device_group) */
+#if defined(VK_KHR_display_swapchain)
+ vkCreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR)load(context, "vkCreateSharedSwapchainsKHR");
+#endif /* defined(VK_KHR_display_swapchain) */
+#if defined(VK_KHR_draw_indirect_count)
+ vkCmdDrawIndexedIndirectCountKHR = (PFN_vkCmdDrawIndexedIndirectCountKHR)load(context, "vkCmdDrawIndexedIndirectCountKHR");
+ vkCmdDrawIndirectCountKHR = (PFN_vkCmdDrawIndirectCountKHR)load(context, "vkCmdDrawIndirectCountKHR");
+#endif /* defined(VK_KHR_draw_indirect_count) */
+#if defined(VK_KHR_external_fence_fd)
+ vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)load(context, "vkGetFenceFdKHR");
+ vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)load(context, "vkImportFenceFdKHR");
+#endif /* defined(VK_KHR_external_fence_fd) */
+#if defined(VK_KHR_external_fence_win32)
+ vkGetFenceWin32HandleKHR = (PFN_vkGetFenceWin32HandleKHR)load(context, "vkGetFenceWin32HandleKHR");
+ vkImportFenceWin32HandleKHR = (PFN_vkImportFenceWin32HandleKHR)load(context, "vkImportFenceWin32HandleKHR");
+#endif /* defined(VK_KHR_external_fence_win32) */
+#if defined(VK_KHR_external_memory_fd)
+ vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)load(context, "vkGetMemoryFdKHR");
+ vkGetMemoryFdPropertiesKHR = (PFN_vkGetMemoryFdPropertiesKHR)load(context, "vkGetMemoryFdPropertiesKHR");
+#endif /* defined(VK_KHR_external_memory_fd) */
+#if defined(VK_KHR_external_memory_win32)
+ vkGetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR)load(context, "vkGetMemoryWin32HandleKHR");
+ vkGetMemoryWin32HandlePropertiesKHR = (PFN_vkGetMemoryWin32HandlePropertiesKHR)load(context, "vkGetMemoryWin32HandlePropertiesKHR");
+#endif /* defined(VK_KHR_external_memory_win32) */
+#if defined(VK_KHR_external_semaphore_fd)
+ vkGetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)load(context, "vkGetSemaphoreFdKHR");
+ vkImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)load(context, "vkImportSemaphoreFdKHR");
+#endif /* defined(VK_KHR_external_semaphore_fd) */
+#if defined(VK_KHR_external_semaphore_win32)
+ vkGetSemaphoreWin32HandleKHR = (PFN_vkGetSemaphoreWin32HandleKHR)load(context, "vkGetSemaphoreWin32HandleKHR");
+ vkImportSemaphoreWin32HandleKHR = (PFN_vkImportSemaphoreWin32HandleKHR)load(context, "vkImportSemaphoreWin32HandleKHR");
+#endif /* defined(VK_KHR_external_semaphore_win32) */
+#if defined(VK_KHR_get_memory_requirements2)
+ vkGetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2KHR)load(context, "vkGetBufferMemoryRequirements2KHR");
+ vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)load(context, "vkGetImageMemoryRequirements2KHR");
+ vkGetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)load(context, "vkGetImageSparseMemoryRequirements2KHR");
+#endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_maintenance1)
+ vkTrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)load(context, "vkTrimCommandPoolKHR");
+#endif /* defined(VK_KHR_maintenance1) */
+#if defined(VK_KHR_maintenance3)
+ vkGetDescriptorSetLayoutSupportKHR = (PFN_vkGetDescriptorSetLayoutSupportKHR)load(context, "vkGetDescriptorSetLayoutSupportKHR");
+#endif /* defined(VK_KHR_maintenance3) */
+#if defined(VK_KHR_performance_query)
+ vkAcquireProfilingLockKHR = (PFN_vkAcquireProfilingLockKHR)load(context, "vkAcquireProfilingLockKHR");
+ vkReleaseProfilingLockKHR = (PFN_vkReleaseProfilingLockKHR)load(context, "vkReleaseProfilingLockKHR");
+#endif /* defined(VK_KHR_performance_query) */
+#if defined(VK_KHR_pipeline_executable_properties)
+ vkGetPipelineExecutableInternalRepresentationsKHR = (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)load(context, "vkGetPipelineExecutableInternalRepresentationsKHR");
+ vkGetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR)load(context, "vkGetPipelineExecutablePropertiesKHR");
+ vkGetPipelineExecutableStatisticsKHR = (PFN_vkGetPipelineExecutableStatisticsKHR)load(context, "vkGetPipelineExecutableStatisticsKHR");
+#endif /* defined(VK_KHR_pipeline_executable_properties) */
+#if defined(VK_KHR_push_descriptor)
+ vkCmdPushDescriptorSetKHR = (PFN_vkCmdPushDescriptorSetKHR)load(context, "vkCmdPushDescriptorSetKHR");
+#endif /* defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_sampler_ycbcr_conversion)
+ vkCreateSamplerYcbcrConversionKHR = (PFN_vkCreateSamplerYcbcrConversionKHR)load(context, "vkCreateSamplerYcbcrConversionKHR");
+ vkDestroySamplerYcbcrConversionKHR = (PFN_vkDestroySamplerYcbcrConversionKHR)load(context, "vkDestroySamplerYcbcrConversionKHR");
+#endif /* defined(VK_KHR_sampler_ycbcr_conversion) */
+#if defined(VK_KHR_shared_presentable_image)
+ vkGetSwapchainStatusKHR = (PFN_vkGetSwapchainStatusKHR)load(context, "vkGetSwapchainStatusKHR");
+#endif /* defined(VK_KHR_shared_presentable_image) */
+#if defined(VK_KHR_swapchain)
+ vkAcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)load(context, "vkAcquireNextImageKHR");
+ vkCreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)load(context, "vkCreateSwapchainKHR");
+ vkDestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)load(context, "vkDestroySwapchainKHR");
+ vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)load(context, "vkGetSwapchainImagesKHR");
+ vkQueuePresentKHR = (PFN_vkQueuePresentKHR)load(context, "vkQueuePresentKHR");
+#endif /* defined(VK_KHR_swapchain) */
+#if defined(VK_KHR_timeline_semaphore)
+ vkGetSemaphoreCounterValueKHR = (PFN_vkGetSemaphoreCounterValueKHR)load(context, "vkGetSemaphoreCounterValueKHR");
+ vkSignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)load(context, "vkSignalSemaphoreKHR");
+ vkWaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)load(context, "vkWaitSemaphoresKHR");
+#endif /* defined(VK_KHR_timeline_semaphore) */
+#if defined(VK_NVX_device_generated_commands)
+ vkCmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)load(context, "vkCmdProcessCommandsNVX");
+ vkCmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)load(context, "vkCmdReserveSpaceForCommandsNVX");
+ vkCreateIndirectCommandsLayoutNVX = (PFN_vkCreateIndirectCommandsLayoutNVX)load(context, "vkCreateIndirectCommandsLayoutNVX");
+ vkCreateObjectTableNVX = (PFN_vkCreateObjectTableNVX)load(context, "vkCreateObjectTableNVX");
+ vkDestroyIndirectCommandsLayoutNVX = (PFN_vkDestroyIndirectCommandsLayoutNVX)load(context, "vkDestroyIndirectCommandsLayoutNVX");
+ vkDestroyObjectTableNVX = (PFN_vkDestroyObjectTableNVX)load(context, "vkDestroyObjectTableNVX");
+ vkRegisterObjectsNVX = (PFN_vkRegisterObjectsNVX)load(context, "vkRegisterObjectsNVX");
+ vkUnregisterObjectsNVX = (PFN_vkUnregisterObjectsNVX)load(context, "vkUnregisterObjectsNVX");
+#endif /* defined(VK_NVX_device_generated_commands) */
+#if defined(VK_NVX_image_view_handle)
+ vkGetImageViewHandleNVX = (PFN_vkGetImageViewHandleNVX)load(context, "vkGetImageViewHandleNVX");
+#endif /* defined(VK_NVX_image_view_handle) */
+#if defined(VK_NV_clip_space_w_scaling)
+ vkCmdSetViewportWScalingNV = (PFN_vkCmdSetViewportWScalingNV)load(context, "vkCmdSetViewportWScalingNV");
+#endif /* defined(VK_NV_clip_space_w_scaling) */
+#if defined(VK_NV_device_diagnostic_checkpoints)
+ vkCmdSetCheckpointNV = (PFN_vkCmdSetCheckpointNV)load(context, "vkCmdSetCheckpointNV");
+ vkGetQueueCheckpointDataNV = (PFN_vkGetQueueCheckpointDataNV)load(context, "vkGetQueueCheckpointDataNV");
+#endif /* defined(VK_NV_device_diagnostic_checkpoints) */
+#if defined(VK_NV_external_memory_win32)
+ vkGetMemoryWin32HandleNV = (PFN_vkGetMemoryWin32HandleNV)load(context, "vkGetMemoryWin32HandleNV");
+#endif /* defined(VK_NV_external_memory_win32) */
+#if defined(VK_NV_mesh_shader)
+ vkCmdDrawMeshTasksIndirectCountNV = (PFN_vkCmdDrawMeshTasksIndirectCountNV)load(context, "vkCmdDrawMeshTasksIndirectCountNV");
+ vkCmdDrawMeshTasksIndirectNV = (PFN_vkCmdDrawMeshTasksIndirectNV)load(context, "vkCmdDrawMeshTasksIndirectNV");
+ vkCmdDrawMeshTasksNV = (PFN_vkCmdDrawMeshTasksNV)load(context, "vkCmdDrawMeshTasksNV");
+#endif /* defined(VK_NV_mesh_shader) */
+#if defined(VK_NV_ray_tracing)
+ vkBindAccelerationStructureMemoryNV = (PFN_vkBindAccelerationStructureMemoryNV)load(context, "vkBindAccelerationStructureMemoryNV");
+ vkCmdBuildAccelerationStructureNV = (PFN_vkCmdBuildAccelerationStructureNV)load(context, "vkCmdBuildAccelerationStructureNV");
+ vkCmdCopyAccelerationStructureNV = (PFN_vkCmdCopyAccelerationStructureNV)load(context, "vkCmdCopyAccelerationStructureNV");
+ vkCmdTraceRaysNV = (PFN_vkCmdTraceRaysNV)load(context, "vkCmdTraceRaysNV");
+ vkCmdWriteAccelerationStructuresPropertiesNV = (PFN_vkCmdWriteAccelerationStructuresPropertiesNV)load(context, "vkCmdWriteAccelerationStructuresPropertiesNV");
+ vkCompileDeferredNV = (PFN_vkCompileDeferredNV)load(context, "vkCompileDeferredNV");
+ vkCreateAccelerationStructureNV = (PFN_vkCreateAccelerationStructureNV)load(context, "vkCreateAccelerationStructureNV");
+ vkCreateRayTracingPipelinesNV = (PFN_vkCreateRayTracingPipelinesNV)load(context, "vkCreateRayTracingPipelinesNV");
+ vkDestroyAccelerationStructureNV = (PFN_vkDestroyAccelerationStructureNV)load(context, "vkDestroyAccelerationStructureNV");
+ vkGetAccelerationStructureHandleNV = (PFN_vkGetAccelerationStructureHandleNV)load(context, "vkGetAccelerationStructureHandleNV");
+ vkGetAccelerationStructureMemoryRequirementsNV = (PFN_vkGetAccelerationStructureMemoryRequirementsNV)load(context, "vkGetAccelerationStructureMemoryRequirementsNV");
+ vkGetRayTracingShaderGroupHandlesNV = (PFN_vkGetRayTracingShaderGroupHandlesNV)load(context, "vkGetRayTracingShaderGroupHandlesNV");
+#endif /* defined(VK_NV_ray_tracing) */
+#if defined(VK_NV_scissor_exclusive)
+ vkCmdSetExclusiveScissorNV = (PFN_vkCmdSetExclusiveScissorNV)load(context, "vkCmdSetExclusiveScissorNV");
+#endif /* defined(VK_NV_scissor_exclusive) */
+#if defined(VK_NV_shading_rate_image)
+ vkCmdBindShadingRateImageNV = (PFN_vkCmdBindShadingRateImageNV)load(context, "vkCmdBindShadingRateImageNV");
+ vkCmdSetCoarseSampleOrderNV = (PFN_vkCmdSetCoarseSampleOrderNV)load(context, "vkCmdSetCoarseSampleOrderNV");
+ vkCmdSetViewportShadingRatePaletteNV = (PFN_vkCmdSetViewportShadingRatePaletteNV)load(context, "vkCmdSetViewportShadingRatePaletteNV");
+#endif /* defined(VK_NV_shading_rate_image) */
+#if (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1))
+ vkGetDeviceGroupSurfacePresentModes2EXT = (PFN_vkGetDeviceGroupSurfacePresentModes2EXT)load(context, "vkGetDeviceGroupSurfacePresentModes2EXT");
+#endif /* (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1))
+ vkCmdPushDescriptorSetWithTemplateKHR = (PFN_vkCmdPushDescriptorSetWithTemplateKHR)load(context, "vkCmdPushDescriptorSetWithTemplateKHR");
+#endif /* (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+ vkGetDeviceGroupPresentCapabilitiesKHR = (PFN_vkGetDeviceGroupPresentCapabilitiesKHR)load(context, "vkGetDeviceGroupPresentCapabilitiesKHR");
+ vkGetDeviceGroupSurfacePresentModesKHR = (PFN_vkGetDeviceGroupSurfacePresentModesKHR)load(context, "vkGetDeviceGroupSurfacePresentModesKHR");
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+ vkAcquireNextImage2KHR = (PFN_vkAcquireNextImage2KHR)load(context, "vkAcquireNextImage2KHR");
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+ /* VOLK_GENERATE_LOAD_DEVICE */
+}
+
+static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context, PFN_vkVoidFunction (*load)(void*, const char*))
+{
+ /* VOLK_GENERATE_LOAD_DEVICE_TABLE */
+#if defined(VK_VERSION_1_0)
+ table->vkAllocateCommandBuffers = (PFN_vkAllocateCommandBuffers)load(context, "vkAllocateCommandBuffers");
+ table->vkAllocateDescriptorSets = (PFN_vkAllocateDescriptorSets)load(context, "vkAllocateDescriptorSets");
+ table->vkAllocateMemory = (PFN_vkAllocateMemory)load(context, "vkAllocateMemory");
+ table->vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer)load(context, "vkBeginCommandBuffer");
+ table->vkBindBufferMemory = (PFN_vkBindBufferMemory)load(context, "vkBindBufferMemory");
+ table->vkBindImageMemory = (PFN_vkBindImageMemory)load(context, "vkBindImageMemory");
+ table->vkCmdBeginQuery = (PFN_vkCmdBeginQuery)load(context, "vkCmdBeginQuery");
+ table->vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)load(context, "vkCmdBeginRenderPass");
+ table->vkCmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets)load(context, "vkCmdBindDescriptorSets");
+ table->vkCmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer)load(context, "vkCmdBindIndexBuffer");
+ table->vkCmdBindPipeline = (PFN_vkCmdBindPipeline)load(context, "vkCmdBindPipeline");
+ table->vkCmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers)load(context, "vkCmdBindVertexBuffers");
+ table->vkCmdBlitImage = (PFN_vkCmdBlitImage)load(context, "vkCmdBlitImage");
+ table->vkCmdClearAttachments = (PFN_vkCmdClearAttachments)load(context, "vkCmdClearAttachments");
+ table->vkCmdClearColorImage = (PFN_vkCmdClearColorImage)load(context, "vkCmdClearColorImage");
+ table->vkCmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage)load(context, "vkCmdClearDepthStencilImage");
+ table->vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)load(context, "vkCmdCopyBuffer");
+ table->vkCmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage)load(context, "vkCmdCopyBufferToImage");
+ table->vkCmdCopyImage = (PFN_vkCmdCopyImage)load(context, "vkCmdCopyImage");
+ table->vkCmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer)load(context, "vkCmdCopyImageToBuffer");
+ table->vkCmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults)load(context, "vkCmdCopyQueryPoolResults");
+ table->vkCmdDispatch = (PFN_vkCmdDispatch)load(context, "vkCmdDispatch");
+ table->vkCmdDispatchIndirect = (PFN_vkCmdDispatchIndirect)load(context, "vkCmdDispatchIndirect");
+ table->vkCmdDraw = (PFN_vkCmdDraw)load(context, "vkCmdDraw");
+ table->vkCmdDrawIndexed = (PFN_vkCmdDrawIndexed)load(context, "vkCmdDrawIndexed");
+ table->vkCmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect)load(context, "vkCmdDrawIndexedIndirect");
+ table->vkCmdDrawIndirect = (PFN_vkCmdDrawIndirect)load(context, "vkCmdDrawIndirect");
+ table->vkCmdEndQuery = (PFN_vkCmdEndQuery)load(context, "vkCmdEndQuery");
+ table->vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass)load(context, "vkCmdEndRenderPass");
+ table->vkCmdExecuteCommands = (PFN_vkCmdExecuteCommands)load(context, "vkCmdExecuteCommands");
+ table->vkCmdFillBuffer = (PFN_vkCmdFillBuffer)load(context, "vkCmdFillBuffer");
+ table->vkCmdNextSubpass = (PFN_vkCmdNextSubpass)load(context, "vkCmdNextSubpass");
+ table->vkCmdPipelineBarrier = (PFN_vkCmdPipelineBarrier)load(context, "vkCmdPipelineBarrier");
+ table->vkCmdPushConstants = (PFN_vkCmdPushConstants)load(context, "vkCmdPushConstants");
+ table->vkCmdResetEvent = (PFN_vkCmdResetEvent)load(context, "vkCmdResetEvent");
+ table->vkCmdResetQueryPool = (PFN_vkCmdResetQueryPool)load(context, "vkCmdResetQueryPool");
+ table->vkCmdResolveImage = (PFN_vkCmdResolveImage)load(context, "vkCmdResolveImage");
+ table->vkCmdSetBlendConstants = (PFN_vkCmdSetBlendConstants)load(context, "vkCmdSetBlendConstants");
+ table->vkCmdSetDepthBias = (PFN_vkCmdSetDepthBias)load(context, "vkCmdSetDepthBias");
+ table->vkCmdSetDepthBounds = (PFN_vkCmdSetDepthBounds)load(context, "vkCmdSetDepthBounds");
+ table->vkCmdSetEvent = (PFN_vkCmdSetEvent)load(context, "vkCmdSetEvent");
+ table->vkCmdSetLineWidth = (PFN_vkCmdSetLineWidth)load(context, "vkCmdSetLineWidth");
+ table->vkCmdSetScissor = (PFN_vkCmdSetScissor)load(context, "vkCmdSetScissor");
+ table->vkCmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask)load(context, "vkCmdSetStencilCompareMask");
+ table->vkCmdSetStencilReference = (PFN_vkCmdSetStencilReference)load(context, "vkCmdSetStencilReference");
+ table->vkCmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask)load(context, "vkCmdSetStencilWriteMask");
+ table->vkCmdSetViewport = (PFN_vkCmdSetViewport)load(context, "vkCmdSetViewport");
+ table->vkCmdUpdateBuffer = (PFN_vkCmdUpdateBuffer)load(context, "vkCmdUpdateBuffer");
+ table->vkCmdWaitEvents = (PFN_vkCmdWaitEvents)load(context, "vkCmdWaitEvents");
+ table->vkCmdWriteTimestamp = (PFN_vkCmdWriteTimestamp)load(context, "vkCmdWriteTimestamp");
+ table->vkCreateBuffer = (PFN_vkCreateBuffer)load(context, "vkCreateBuffer");
+ table->vkCreateBufferView = (PFN_vkCreateBufferView)load(context, "vkCreateBufferView");
+ table->vkCreateCommandPool = (PFN_vkCreateCommandPool)load(context, "vkCreateCommandPool");
+ table->vkCreateComputePipelines = (PFN_vkCreateComputePipelines)load(context, "vkCreateComputePipelines");
+ table->vkCreateDescriptorPool = (PFN_vkCreateDescriptorPool)load(context, "vkCreateDescriptorPool");
+ table->vkCreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout)load(context, "vkCreateDescriptorSetLayout");
+ table->vkCreateEvent = (PFN_vkCreateEvent)load(context, "vkCreateEvent");
+ table->vkCreateFence = (PFN_vkCreateFence)load(context, "vkCreateFence");
+ table->vkCreateFramebuffer = (PFN_vkCreateFramebuffer)load(context, "vkCreateFramebuffer");
+ table->vkCreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines)load(context, "vkCreateGraphicsPipelines");
+ table->vkCreateImage = (PFN_vkCreateImage)load(context, "vkCreateImage");
+ table->vkCreateImageView = (PFN_vkCreateImageView)load(context, "vkCreateImageView");
+ table->vkCreatePipelineCache = (PFN_vkCreatePipelineCache)load(context, "vkCreatePipelineCache");
+ table->vkCreatePipelineLayout = (PFN_vkCreatePipelineLayout)load(context, "vkCreatePipelineLayout");
+ table->vkCreateQueryPool = (PFN_vkCreateQueryPool)load(context, "vkCreateQueryPool");
+ table->vkCreateRenderPass = (PFN_vkCreateRenderPass)load(context, "vkCreateRenderPass");
+ table->vkCreateSampler = (PFN_vkCreateSampler)load(context, "vkCreateSampler");
+ table->vkCreateSemaphore = (PFN_vkCreateSemaphore)load(context, "vkCreateSemaphore");
+ table->vkCreateShaderModule = (PFN_vkCreateShaderModule)load(context, "vkCreateShaderModule");
+ table->vkDestroyBuffer = (PFN_vkDestroyBuffer)load(context, "vkDestroyBuffer");
+ table->vkDestroyBufferView = (PFN_vkDestroyBufferView)load(context, "vkDestroyBufferView");
+ table->vkDestroyCommandPool = (PFN_vkDestroyCommandPool)load(context, "vkDestroyCommandPool");
+ table->vkDestroyDescriptorPool = (PFN_vkDestroyDescriptorPool)load(context, "vkDestroyDescriptorPool");
+ table->vkDestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout)load(context, "vkDestroyDescriptorSetLayout");
+ table->vkDestroyDevice = (PFN_vkDestroyDevice)load(context, "vkDestroyDevice");
+ table->vkDestroyEvent = (PFN_vkDestroyEvent)load(context, "vkDestroyEvent");
+ table->vkDestroyFence = (PFN_vkDestroyFence)load(context, "vkDestroyFence");
+ table->vkDestroyFramebuffer = (PFN_vkDestroyFramebuffer)load(context, "vkDestroyFramebuffer");
+ table->vkDestroyImage = (PFN_vkDestroyImage)load(context, "vkDestroyImage");
+ table->vkDestroyImageView = (PFN_vkDestroyImageView)load(context, "vkDestroyImageView");
+ table->vkDestroyPipeline = (PFN_vkDestroyPipeline)load(context, "vkDestroyPipeline");
+ table->vkDestroyPipelineCache = (PFN_vkDestroyPipelineCache)load(context, "vkDestroyPipelineCache");
+ table->vkDestroyPipelineLayout = (PFN_vkDestroyPipelineLayout)load(context, "vkDestroyPipelineLayout");
+ table->vkDestroyQueryPool = (PFN_vkDestroyQueryPool)load(context, "vkDestroyQueryPool");
+ table->vkDestroyRenderPass = (PFN_vkDestroyRenderPass)load(context, "vkDestroyRenderPass");
+ table->vkDestroySampler = (PFN_vkDestroySampler)load(context, "vkDestroySampler");
+ table->vkDestroySemaphore = (PFN_vkDestroySemaphore)load(context, "vkDestroySemaphore");
+ table->vkDestroyShaderModule = (PFN_vkDestroyShaderModule)load(context, "vkDestroyShaderModule");
+ table->vkDeviceWaitIdle = (PFN_vkDeviceWaitIdle)load(context, "vkDeviceWaitIdle");
+ table->vkEndCommandBuffer = (PFN_vkEndCommandBuffer)load(context, "vkEndCommandBuffer");
+ table->vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)load(context, "vkFlushMappedMemoryRanges");
+ table->vkFreeCommandBuffers = (PFN_vkFreeCommandBuffers)load(context, "vkFreeCommandBuffers");
+ table->vkFreeDescriptorSets = (PFN_vkFreeDescriptorSets)load(context, "vkFreeDescriptorSets");
+ table->vkFreeMemory = (PFN_vkFreeMemory)load(context, "vkFreeMemory");
+ table->vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)load(context, "vkGetBufferMemoryRequirements");
+ table->vkGetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment)load(context, "vkGetDeviceMemoryCommitment");
+ table->vkGetDeviceQueue = (PFN_vkGetDeviceQueue)load(context, "vkGetDeviceQueue");
+ table->vkGetEventStatus = (PFN_vkGetEventStatus)load(context, "vkGetEventStatus");
+ table->vkGetFenceStatus = (PFN_vkGetFenceStatus)load(context, "vkGetFenceStatus");
+ table->vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)load(context, "vkGetImageMemoryRequirements");
+ table->vkGetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements)load(context, "vkGetImageSparseMemoryRequirements");
+ table->vkGetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout)load(context, "vkGetImageSubresourceLayout");
+ table->vkGetPipelineCacheData = (PFN_vkGetPipelineCacheData)load(context, "vkGetPipelineCacheData");
+ table->vkGetQueryPoolResults = (PFN_vkGetQueryPoolResults)load(context, "vkGetQueryPoolResults");
+ table->vkGetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity)load(context, "vkGetRenderAreaGranularity");
+ table->vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)load(context, "vkInvalidateMappedMemoryRanges");
+ table->vkMapMemory = (PFN_vkMapMemory)load(context, "vkMapMemory");
+ table->vkMergePipelineCaches = (PFN_vkMergePipelineCaches)load(context, "vkMergePipelineCaches");
+ table->vkQueueBindSparse = (PFN_vkQueueBindSparse)load(context, "vkQueueBindSparse");
+ table->vkQueueSubmit = (PFN_vkQueueSubmit)load(context, "vkQueueSubmit");
+ table->vkQueueWaitIdle = (PFN_vkQueueWaitIdle)load(context, "vkQueueWaitIdle");
+ table->vkResetCommandBuffer = (PFN_vkResetCommandBuffer)load(context, "vkResetCommandBuffer");
+ table->vkResetCommandPool = (PFN_vkResetCommandPool)load(context, "vkResetCommandPool");
+ table->vkResetDescriptorPool = (PFN_vkResetDescriptorPool)load(context, "vkResetDescriptorPool");
+ table->vkResetEvent = (PFN_vkResetEvent)load(context, "vkResetEvent");
+ table->vkResetFences = (PFN_vkResetFences)load(context, "vkResetFences");
+ table->vkSetEvent = (PFN_vkSetEvent)load(context, "vkSetEvent");
+ table->vkUnmapMemory = (PFN_vkUnmapMemory)load(context, "vkUnmapMemory");
+ table->vkUpdateDescriptorSets = (PFN_vkUpdateDescriptorSets)load(context, "vkUpdateDescriptorSets");
+ table->vkWaitForFences = (PFN_vkWaitForFences)load(context, "vkWaitForFences");
+#endif /* defined(VK_VERSION_1_0) */
+#if defined(VK_VERSION_1_1)
+ table->vkBindBufferMemory2 = (PFN_vkBindBufferMemory2)load(context, "vkBindBufferMemory2");
+ table->vkBindImageMemory2 = (PFN_vkBindImageMemory2)load(context, "vkBindImageMemory2");
+ table->vkCmdDispatchBase = (PFN_vkCmdDispatchBase)load(context, "vkCmdDispatchBase");
+ table->vkCmdSetDeviceMask = (PFN_vkCmdSetDeviceMask)load(context, "vkCmdSetDeviceMask");
+ table->vkCreateDescriptorUpdateTemplate = (PFN_vkCreateDescriptorUpdateTemplate)load(context, "vkCreateDescriptorUpdateTemplate");
+ table->vkCreateSamplerYcbcrConversion = (PFN_vkCreateSamplerYcbcrConversion)load(context, "vkCreateSamplerYcbcrConversion");
+ table->vkDestroyDescriptorUpdateTemplate = (PFN_vkDestroyDescriptorUpdateTemplate)load(context, "vkDestroyDescriptorUpdateTemplate");
+ table->vkDestroySamplerYcbcrConversion = (PFN_vkDestroySamplerYcbcrConversion)load(context, "vkDestroySamplerYcbcrConversion");
+ table->vkGetBufferMemoryRequirements2 = (PFN_vkGetBufferMemoryRequirements2)load(context, "vkGetBufferMemoryRequirements2");
+ table->vkGetDescriptorSetLayoutSupport = (PFN_vkGetDescriptorSetLayoutSupport)load(context, "vkGetDescriptorSetLayoutSupport");
+ table->vkGetDeviceGroupPeerMemoryFeatures = (PFN_vkGetDeviceGroupPeerMemoryFeatures)load(context, "vkGetDeviceGroupPeerMemoryFeatures");
+ table->vkGetDeviceQueue2 = (PFN_vkGetDeviceQueue2)load(context, "vkGetDeviceQueue2");
+ table->vkGetImageMemoryRequirements2 = (PFN_vkGetImageMemoryRequirements2)load(context, "vkGetImageMemoryRequirements2");
+ table->vkGetImageSparseMemoryRequirements2 = (PFN_vkGetImageSparseMemoryRequirements2)load(context, "vkGetImageSparseMemoryRequirements2");
+ table->vkTrimCommandPool = (PFN_vkTrimCommandPool)load(context, "vkTrimCommandPool");
+ table->vkUpdateDescriptorSetWithTemplate = (PFN_vkUpdateDescriptorSetWithTemplate)load(context, "vkUpdateDescriptorSetWithTemplate");
+#endif /* defined(VK_VERSION_1_1) */
+#if defined(VK_VERSION_1_2)
+ table->vkCmdBeginRenderPass2 = (PFN_vkCmdBeginRenderPass2)load(context, "vkCmdBeginRenderPass2");
+ table->vkCmdDrawIndexedIndirectCount = (PFN_vkCmdDrawIndexedIndirectCount)load(context, "vkCmdDrawIndexedIndirectCount");
+ table->vkCmdDrawIndirectCount = (PFN_vkCmdDrawIndirectCount)load(context, "vkCmdDrawIndirectCount");
+ table->vkCmdEndRenderPass2 = (PFN_vkCmdEndRenderPass2)load(context, "vkCmdEndRenderPass2");
+ table->vkCmdNextSubpass2 = (PFN_vkCmdNextSubpass2)load(context, "vkCmdNextSubpass2");
+ table->vkCreateRenderPass2 = (PFN_vkCreateRenderPass2)load(context, "vkCreateRenderPass2");
+ table->vkGetBufferDeviceAddress = (PFN_vkGetBufferDeviceAddress)load(context, "vkGetBufferDeviceAddress");
+ table->vkGetBufferOpaqueCaptureAddress = (PFN_vkGetBufferOpaqueCaptureAddress)load(context, "vkGetBufferOpaqueCaptureAddress");
+ table->vkGetDeviceMemoryOpaqueCaptureAddress = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)load(context, "vkGetDeviceMemoryOpaqueCaptureAddress");
+ table->vkGetSemaphoreCounterValue = (PFN_vkGetSemaphoreCounterValue)load(context, "vkGetSemaphoreCounterValue");
+ table->vkResetQueryPool = (PFN_vkResetQueryPool)load(context, "vkResetQueryPool");
+ table->vkSignalSemaphore = (PFN_vkSignalSemaphore)load(context, "vkSignalSemaphore");
+ table->vkWaitSemaphores = (PFN_vkWaitSemaphores)load(context, "vkWaitSemaphores");
+#endif /* defined(VK_VERSION_1_2) */
+#if defined(VK_AMD_buffer_marker)
+ table->vkCmdWriteBufferMarkerAMD = (PFN_vkCmdWriteBufferMarkerAMD)load(context, "vkCmdWriteBufferMarkerAMD");
+#endif /* defined(VK_AMD_buffer_marker) */
+#if defined(VK_AMD_display_native_hdr)
+ table->vkSetLocalDimmingAMD = (PFN_vkSetLocalDimmingAMD)load(context, "vkSetLocalDimmingAMD");
+#endif /* defined(VK_AMD_display_native_hdr) */
+#if defined(VK_AMD_draw_indirect_count)
+ table->vkCmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)load(context, "vkCmdDrawIndexedIndirectCountAMD");
+ table->vkCmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)load(context, "vkCmdDrawIndirectCountAMD");
+#endif /* defined(VK_AMD_draw_indirect_count) */
+#if defined(VK_AMD_shader_info)
+ table->vkGetShaderInfoAMD = (PFN_vkGetShaderInfoAMD)load(context, "vkGetShaderInfoAMD");
+#endif /* defined(VK_AMD_shader_info) */
+#if defined(VK_ANDROID_external_memory_android_hardware_buffer)
+ table->vkGetAndroidHardwareBufferPropertiesANDROID = (PFN_vkGetAndroidHardwareBufferPropertiesANDROID)load(context, "vkGetAndroidHardwareBufferPropertiesANDROID");
+ table->vkGetMemoryAndroidHardwareBufferANDROID = (PFN_vkGetMemoryAndroidHardwareBufferANDROID)load(context, "vkGetMemoryAndroidHardwareBufferANDROID");
+#endif /* defined(VK_ANDROID_external_memory_android_hardware_buffer) */
+#if defined(VK_EXT_buffer_device_address)
+ table->vkGetBufferDeviceAddressEXT = (PFN_vkGetBufferDeviceAddressEXT)load(context, "vkGetBufferDeviceAddressEXT");
+#endif /* defined(VK_EXT_buffer_device_address) */
+#if defined(VK_EXT_calibrated_timestamps)
+ table->vkGetCalibratedTimestampsEXT = (PFN_vkGetCalibratedTimestampsEXT)load(context, "vkGetCalibratedTimestampsEXT");
+#endif /* defined(VK_EXT_calibrated_timestamps) */
+#if defined(VK_EXT_conditional_rendering)
+ table->vkCmdBeginConditionalRenderingEXT = (PFN_vkCmdBeginConditionalRenderingEXT)load(context, "vkCmdBeginConditionalRenderingEXT");
+ table->vkCmdEndConditionalRenderingEXT = (PFN_vkCmdEndConditionalRenderingEXT)load(context, "vkCmdEndConditionalRenderingEXT");
+#endif /* defined(VK_EXT_conditional_rendering) */
+#if defined(VK_EXT_debug_marker)
+ table->vkCmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT)load(context, "vkCmdDebugMarkerBeginEXT");
+ table->vkCmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT)load(context, "vkCmdDebugMarkerEndEXT");
+ table->vkCmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT)load(context, "vkCmdDebugMarkerInsertEXT");
+ table->vkDebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)load(context, "vkDebugMarkerSetObjectNameEXT");
+ table->vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)load(context, "vkDebugMarkerSetObjectTagEXT");
+#endif /* defined(VK_EXT_debug_marker) */
+#if defined(VK_EXT_discard_rectangles)
+ table->vkCmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)load(context, "vkCmdSetDiscardRectangleEXT");
+#endif /* defined(VK_EXT_discard_rectangles) */
+#if defined(VK_EXT_display_control)
+ table->vkDisplayPowerControlEXT = (PFN_vkDisplayPowerControlEXT)load(context, "vkDisplayPowerControlEXT");
+ table->vkGetSwapchainCounterEXT = (PFN_vkGetSwapchainCounterEXT)load(context, "vkGetSwapchainCounterEXT");
+ table->vkRegisterDeviceEventEXT = (PFN_vkRegisterDeviceEventEXT)load(context, "vkRegisterDeviceEventEXT");
+ table->vkRegisterDisplayEventEXT = (PFN_vkRegisterDisplayEventEXT)load(context, "vkRegisterDisplayEventEXT");
+#endif /* defined(VK_EXT_display_control) */
+#if defined(VK_EXT_external_memory_host)
+ table->vkGetMemoryHostPointerPropertiesEXT = (PFN_vkGetMemoryHostPointerPropertiesEXT)load(context, "vkGetMemoryHostPointerPropertiesEXT");
+#endif /* defined(VK_EXT_external_memory_host) */
+#if defined(VK_EXT_full_screen_exclusive)
+ table->vkAcquireFullScreenExclusiveModeEXT = (PFN_vkAcquireFullScreenExclusiveModeEXT)load(context, "vkAcquireFullScreenExclusiveModeEXT");
+ table->vkReleaseFullScreenExclusiveModeEXT = (PFN_vkReleaseFullScreenExclusiveModeEXT)load(context, "vkReleaseFullScreenExclusiveModeEXT");
+#endif /* defined(VK_EXT_full_screen_exclusive) */
+#if defined(VK_EXT_hdr_metadata)
+ table->vkSetHdrMetadataEXT = (PFN_vkSetHdrMetadataEXT)load(context, "vkSetHdrMetadataEXT");
+#endif /* defined(VK_EXT_hdr_metadata) */
+#if defined(VK_EXT_host_query_reset)
+ table->vkResetQueryPoolEXT = (PFN_vkResetQueryPoolEXT)load(context, "vkResetQueryPoolEXT");
+#endif /* defined(VK_EXT_host_query_reset) */
+#if defined(VK_EXT_image_drm_format_modifier)
+ table->vkGetImageDrmFormatModifierPropertiesEXT = (PFN_vkGetImageDrmFormatModifierPropertiesEXT)load(context, "vkGetImageDrmFormatModifierPropertiesEXT");
+#endif /* defined(VK_EXT_image_drm_format_modifier) */
+#if defined(VK_EXT_line_rasterization)
+ table->vkCmdSetLineStippleEXT = (PFN_vkCmdSetLineStippleEXT)load(context, "vkCmdSetLineStippleEXT");
+#endif /* defined(VK_EXT_line_rasterization) */
+#if defined(VK_EXT_sample_locations)
+ table->vkCmdSetSampleLocationsEXT = (PFN_vkCmdSetSampleLocationsEXT)load(context, "vkCmdSetSampleLocationsEXT");
+#endif /* defined(VK_EXT_sample_locations) */
+#if defined(VK_EXT_transform_feedback)
+ table->vkCmdBeginQueryIndexedEXT = (PFN_vkCmdBeginQueryIndexedEXT)load(context, "vkCmdBeginQueryIndexedEXT");
+ table->vkCmdBeginTransformFeedbackEXT = (PFN_vkCmdBeginTransformFeedbackEXT)load(context, "vkCmdBeginTransformFeedbackEXT");
+ table->vkCmdBindTransformFeedbackBuffersEXT = (PFN_vkCmdBindTransformFeedbackBuffersEXT)load(context, "vkCmdBindTransformFeedbackBuffersEXT");
+ table->vkCmdDrawIndirectByteCountEXT = (PFN_vkCmdDrawIndirectByteCountEXT)load(context, "vkCmdDrawIndirectByteCountEXT");
+ table->vkCmdEndQueryIndexedEXT = (PFN_vkCmdEndQueryIndexedEXT)load(context, "vkCmdEndQueryIndexedEXT");
+ table->vkCmdEndTransformFeedbackEXT = (PFN_vkCmdEndTransformFeedbackEXT)load(context, "vkCmdEndTransformFeedbackEXT");
+#endif /* defined(VK_EXT_transform_feedback) */
+#if defined(VK_EXT_validation_cache)
+ table->vkCreateValidationCacheEXT = (PFN_vkCreateValidationCacheEXT)load(context, "vkCreateValidationCacheEXT");
+ table->vkDestroyValidationCacheEXT = (PFN_vkDestroyValidationCacheEXT)load(context, "vkDestroyValidationCacheEXT");
+ table->vkGetValidationCacheDataEXT = (PFN_vkGetValidationCacheDataEXT)load(context, "vkGetValidationCacheDataEXT");
+ table->vkMergeValidationCachesEXT = (PFN_vkMergeValidationCachesEXT)load(context, "vkMergeValidationCachesEXT");
+#endif /* defined(VK_EXT_validation_cache) */
+#if defined(VK_GOOGLE_display_timing)
+ table->vkGetPastPresentationTimingGOOGLE = (PFN_vkGetPastPresentationTimingGOOGLE)load(context, "vkGetPastPresentationTimingGOOGLE");
+ table->vkGetRefreshCycleDurationGOOGLE = (PFN_vkGetRefreshCycleDurationGOOGLE)load(context, "vkGetRefreshCycleDurationGOOGLE");
+#endif /* defined(VK_GOOGLE_display_timing) */
+#if defined(VK_INTEL_performance_query)
+ table->vkAcquirePerformanceConfigurationINTEL = (PFN_vkAcquirePerformanceConfigurationINTEL)load(context, "vkAcquirePerformanceConfigurationINTEL");
+ table->vkCmdSetPerformanceMarkerINTEL = (PFN_vkCmdSetPerformanceMarkerINTEL)load(context, "vkCmdSetPerformanceMarkerINTEL");
+ table->vkCmdSetPerformanceOverrideINTEL = (PFN_vkCmdSetPerformanceOverrideINTEL)load(context, "vkCmdSetPerformanceOverrideINTEL");
+ table->vkCmdSetPerformanceStreamMarkerINTEL = (PFN_vkCmdSetPerformanceStreamMarkerINTEL)load(context, "vkCmdSetPerformanceStreamMarkerINTEL");
+ table->vkGetPerformanceParameterINTEL = (PFN_vkGetPerformanceParameterINTEL)load(context, "vkGetPerformanceParameterINTEL");
+ table->vkInitializePerformanceApiINTEL = (PFN_vkInitializePerformanceApiINTEL)load(context, "vkInitializePerformanceApiINTEL");
+ table->vkQueueSetPerformanceConfigurationINTEL = (PFN_vkQueueSetPerformanceConfigurationINTEL)load(context, "vkQueueSetPerformanceConfigurationINTEL");
+ table->vkReleasePerformanceConfigurationINTEL = (PFN_vkReleasePerformanceConfigurationINTEL)load(context, "vkReleasePerformanceConfigurationINTEL");
+ table->vkUninitializePerformanceApiINTEL = (PFN_vkUninitializePerformanceApiINTEL)load(context, "vkUninitializePerformanceApiINTEL");
+#endif /* defined(VK_INTEL_performance_query) */
+#if defined(VK_KHR_bind_memory2)
+ table->vkBindBufferMemory2KHR = (PFN_vkBindBufferMemory2KHR)load(context, "vkBindBufferMemory2KHR");
+ table->vkBindImageMemory2KHR = (PFN_vkBindImageMemory2KHR)load(context, "vkBindImageMemory2KHR");
+#endif /* defined(VK_KHR_bind_memory2) */
+#if defined(VK_KHR_buffer_device_address)
+ table->vkGetBufferDeviceAddressKHR = (PFN_vkGetBufferDeviceAddressKHR)load(context, "vkGetBufferDeviceAddressKHR");
+ table->vkGetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)load(context, "vkGetBufferOpaqueCaptureAddressKHR");
+ table->vkGetDeviceMemoryOpaqueCaptureAddressKHR = (PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)load(context, "vkGetDeviceMemoryOpaqueCaptureAddressKHR");
+#endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_create_renderpass2)
+ table->vkCmdBeginRenderPass2KHR = (PFN_vkCmdBeginRenderPass2KHR)load(context, "vkCmdBeginRenderPass2KHR");
+ table->vkCmdEndRenderPass2KHR = (PFN_vkCmdEndRenderPass2KHR)load(context, "vkCmdEndRenderPass2KHR");
+ table->vkCmdNextSubpass2KHR = (PFN_vkCmdNextSubpass2KHR)load(context, "vkCmdNextSubpass2KHR");
+ table->vkCreateRenderPass2KHR = (PFN_vkCreateRenderPass2KHR)load(context, "vkCreateRenderPass2KHR");
+#endif /* defined(VK_KHR_create_renderpass2) */
+#if defined(VK_KHR_descriptor_update_template)
+ table->vkCreateDescriptorUpdateTemplateKHR = (PFN_vkCreateDescriptorUpdateTemplateKHR)load(context, "vkCreateDescriptorUpdateTemplateKHR");
+ table->vkDestroyDescriptorUpdateTemplateKHR = (PFN_vkDestroyDescriptorUpdateTemplateKHR)load(context, "vkDestroyDescriptorUpdateTemplateKHR");
+ table->vkUpdateDescriptorSetWithTemplateKHR = (PFN_vkUpdateDescriptorSetWithTemplateKHR)load(context, "vkUpdateDescriptorSetWithTemplateKHR");
+#endif /* defined(VK_KHR_descriptor_update_template) */
+#if defined(VK_KHR_device_group)
+ table->vkCmdDispatchBaseKHR = (PFN_vkCmdDispatchBaseKHR)load(context, "vkCmdDispatchBaseKHR");
+ table->vkCmdSetDeviceMaskKHR = (PFN_vkCmdSetDeviceMaskKHR)load(context, "vkCmdSetDeviceMaskKHR");
+ table->vkGetDeviceGroupPeerMemoryFeaturesKHR = (PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)load(context, "vkGetDeviceGroupPeerMemoryFeaturesKHR");
+#endif /* defined(VK_KHR_device_group) */
+#if defined(VK_KHR_display_swapchain)
+ table->vkCreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR)load(context, "vkCreateSharedSwapchainsKHR");
+#endif /* defined(VK_KHR_display_swapchain) */
+#if defined(VK_KHR_draw_indirect_count)
+ table->vkCmdDrawIndexedIndirectCountKHR = (PFN_vkCmdDrawIndexedIndirectCountKHR)load(context, "vkCmdDrawIndexedIndirectCountKHR");
+ table->vkCmdDrawIndirectCountKHR = (PFN_vkCmdDrawIndirectCountKHR)load(context, "vkCmdDrawIndirectCountKHR");
+#endif /* defined(VK_KHR_draw_indirect_count) */
+#if defined(VK_KHR_external_fence_fd)
+ table->vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)load(context, "vkGetFenceFdKHR");
+ table->vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)load(context, "vkImportFenceFdKHR");
+#endif /* defined(VK_KHR_external_fence_fd) */
+#if defined(VK_KHR_external_fence_win32)
+ table->vkGetFenceWin32HandleKHR = (PFN_vkGetFenceWin32HandleKHR)load(context, "vkGetFenceWin32HandleKHR");
+ table->vkImportFenceWin32HandleKHR = (PFN_vkImportFenceWin32HandleKHR)load(context, "vkImportFenceWin32HandleKHR");
+#endif /* defined(VK_KHR_external_fence_win32) */
+#if defined(VK_KHR_external_memory_fd)
+ table->vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)load(context, "vkGetMemoryFdKHR");
+ table->vkGetMemoryFdPropertiesKHR = (PFN_vkGetMemoryFdPropertiesKHR)load(context, "vkGetMemoryFdPropertiesKHR");
+#endif /* defined(VK_KHR_external_memory_fd) */
+#if defined(VK_KHR_external_memory_win32)
+ table->vkGetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR)load(context, "vkGetMemoryWin32HandleKHR");
+ table->vkGetMemoryWin32HandlePropertiesKHR = (PFN_vkGetMemoryWin32HandlePropertiesKHR)load(context, "vkGetMemoryWin32HandlePropertiesKHR");
+#endif /* defined(VK_KHR_external_memory_win32) */
+#if defined(VK_KHR_external_semaphore_fd)
+ table->vkGetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)load(context, "vkGetSemaphoreFdKHR");
+ table->vkImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)load(context, "vkImportSemaphoreFdKHR");
+#endif /* defined(VK_KHR_external_semaphore_fd) */
+#if defined(VK_KHR_external_semaphore_win32)
+ table->vkGetSemaphoreWin32HandleKHR = (PFN_vkGetSemaphoreWin32HandleKHR)load(context, "vkGetSemaphoreWin32HandleKHR");
+ table->vkImportSemaphoreWin32HandleKHR = (PFN_vkImportSemaphoreWin32HandleKHR)load(context, "vkImportSemaphoreWin32HandleKHR");
+#endif /* defined(VK_KHR_external_semaphore_win32) */
+#if defined(VK_KHR_get_memory_requirements2)
+ table->vkGetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2KHR)load(context, "vkGetBufferMemoryRequirements2KHR");
+ table->vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)load(context, "vkGetImageMemoryRequirements2KHR");
+ table->vkGetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)load(context, "vkGetImageSparseMemoryRequirements2KHR");
+#endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_maintenance1)
+ table->vkTrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)load(context, "vkTrimCommandPoolKHR");
+#endif /* defined(VK_KHR_maintenance1) */
+#if defined(VK_KHR_maintenance3)
+ table->vkGetDescriptorSetLayoutSupportKHR = (PFN_vkGetDescriptorSetLayoutSupportKHR)load(context, "vkGetDescriptorSetLayoutSupportKHR");
+#endif /* defined(VK_KHR_maintenance3) */
+#if defined(VK_KHR_performance_query)
+ table->vkAcquireProfilingLockKHR = (PFN_vkAcquireProfilingLockKHR)load(context, "vkAcquireProfilingLockKHR");
+ table->vkReleaseProfilingLockKHR = (PFN_vkReleaseProfilingLockKHR)load(context, "vkReleaseProfilingLockKHR");
+#endif /* defined(VK_KHR_performance_query) */
+#if defined(VK_KHR_pipeline_executable_properties)
+ table->vkGetPipelineExecutableInternalRepresentationsKHR = (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)load(context, "vkGetPipelineExecutableInternalRepresentationsKHR");
+ table->vkGetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR)load(context, "vkGetPipelineExecutablePropertiesKHR");
+ table->vkGetPipelineExecutableStatisticsKHR = (PFN_vkGetPipelineExecutableStatisticsKHR)load(context, "vkGetPipelineExecutableStatisticsKHR");
+#endif /* defined(VK_KHR_pipeline_executable_properties) */
+#if defined(VK_KHR_push_descriptor)
+ table->vkCmdPushDescriptorSetKHR = (PFN_vkCmdPushDescriptorSetKHR)load(context, "vkCmdPushDescriptorSetKHR");
+#endif /* defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_sampler_ycbcr_conversion)
+ table->vkCreateSamplerYcbcrConversionKHR = (PFN_vkCreateSamplerYcbcrConversionKHR)load(context, "vkCreateSamplerYcbcrConversionKHR");
+ table->vkDestroySamplerYcbcrConversionKHR = (PFN_vkDestroySamplerYcbcrConversionKHR)load(context, "vkDestroySamplerYcbcrConversionKHR");
+#endif /* defined(VK_KHR_sampler_ycbcr_conversion) */
+#if defined(VK_KHR_shared_presentable_image)
+ table->vkGetSwapchainStatusKHR = (PFN_vkGetSwapchainStatusKHR)load(context, "vkGetSwapchainStatusKHR");
+#endif /* defined(VK_KHR_shared_presentable_image) */
+#if defined(VK_KHR_swapchain)
+ table->vkAcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)load(context, "vkAcquireNextImageKHR");
+ table->vkCreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)load(context, "vkCreateSwapchainKHR");
+ table->vkDestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)load(context, "vkDestroySwapchainKHR");
+ table->vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)load(context, "vkGetSwapchainImagesKHR");
+ table->vkQueuePresentKHR = (PFN_vkQueuePresentKHR)load(context, "vkQueuePresentKHR");
+#endif /* defined(VK_KHR_swapchain) */
+#if defined(VK_KHR_timeline_semaphore)
+ table->vkGetSemaphoreCounterValueKHR = (PFN_vkGetSemaphoreCounterValueKHR)load(context, "vkGetSemaphoreCounterValueKHR");
+ table->vkSignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)load(context, "vkSignalSemaphoreKHR");
+ table->vkWaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)load(context, "vkWaitSemaphoresKHR");
+#endif /* defined(VK_KHR_timeline_semaphore) */
+#if defined(VK_NVX_device_generated_commands)
+ table->vkCmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)load(context, "vkCmdProcessCommandsNVX");
+ table->vkCmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)load(context, "vkCmdReserveSpaceForCommandsNVX");
+ table->vkCreateIndirectCommandsLayoutNVX = (PFN_vkCreateIndirectCommandsLayoutNVX)load(context, "vkCreateIndirectCommandsLayoutNVX");
+ table->vkCreateObjectTableNVX = (PFN_vkCreateObjectTableNVX)load(context, "vkCreateObjectTableNVX");
+ table->vkDestroyIndirectCommandsLayoutNVX = (PFN_vkDestroyIndirectCommandsLayoutNVX)load(context, "vkDestroyIndirectCommandsLayoutNVX");
+ table->vkDestroyObjectTableNVX = (PFN_vkDestroyObjectTableNVX)load(context, "vkDestroyObjectTableNVX");
+ table->vkRegisterObjectsNVX = (PFN_vkRegisterObjectsNVX)load(context, "vkRegisterObjectsNVX");
+ table->vkUnregisterObjectsNVX = (PFN_vkUnregisterObjectsNVX)load(context, "vkUnregisterObjectsNVX");
+#endif /* defined(VK_NVX_device_generated_commands) */
+#if defined(VK_NVX_image_view_handle)
+ table->vkGetImageViewHandleNVX = (PFN_vkGetImageViewHandleNVX)load(context, "vkGetImageViewHandleNVX");
+#endif /* defined(VK_NVX_image_view_handle) */
+#if defined(VK_NV_clip_space_w_scaling)
+ table->vkCmdSetViewportWScalingNV = (PFN_vkCmdSetViewportWScalingNV)load(context, "vkCmdSetViewportWScalingNV");
+#endif /* defined(VK_NV_clip_space_w_scaling) */
+#if defined(VK_NV_device_diagnostic_checkpoints)
+ table->vkCmdSetCheckpointNV = (PFN_vkCmdSetCheckpointNV)load(context, "vkCmdSetCheckpointNV");
+ table->vkGetQueueCheckpointDataNV = (PFN_vkGetQueueCheckpointDataNV)load(context, "vkGetQueueCheckpointDataNV");
+#endif /* defined(VK_NV_device_diagnostic_checkpoints) */
+#if defined(VK_NV_external_memory_win32)
+ table->vkGetMemoryWin32HandleNV = (PFN_vkGetMemoryWin32HandleNV)load(context, "vkGetMemoryWin32HandleNV");
+#endif /* defined(VK_NV_external_memory_win32) */
+#if defined(VK_NV_mesh_shader)
+ table->vkCmdDrawMeshTasksIndirectCountNV = (PFN_vkCmdDrawMeshTasksIndirectCountNV)load(context, "vkCmdDrawMeshTasksIndirectCountNV");
+ table->vkCmdDrawMeshTasksIndirectNV = (PFN_vkCmdDrawMeshTasksIndirectNV)load(context, "vkCmdDrawMeshTasksIndirectNV");
+ table->vkCmdDrawMeshTasksNV = (PFN_vkCmdDrawMeshTasksNV)load(context, "vkCmdDrawMeshTasksNV");
+#endif /* defined(VK_NV_mesh_shader) */
+#if defined(VK_NV_ray_tracing)
+ table->vkBindAccelerationStructureMemoryNV = (PFN_vkBindAccelerationStructureMemoryNV)load(context, "vkBindAccelerationStructureMemoryNV");
+ table->vkCmdBuildAccelerationStructureNV = (PFN_vkCmdBuildAccelerationStructureNV)load(context, "vkCmdBuildAccelerationStructureNV");
+ table->vkCmdCopyAccelerationStructureNV = (PFN_vkCmdCopyAccelerationStructureNV)load(context, "vkCmdCopyAccelerationStructureNV");
+ table->vkCmdTraceRaysNV = (PFN_vkCmdTraceRaysNV)load(context, "vkCmdTraceRaysNV");
+ table->vkCmdWriteAccelerationStructuresPropertiesNV = (PFN_vkCmdWriteAccelerationStructuresPropertiesNV)load(context, "vkCmdWriteAccelerationStructuresPropertiesNV");
+ table->vkCompileDeferredNV = (PFN_vkCompileDeferredNV)load(context, "vkCompileDeferredNV");
+ table->vkCreateAccelerationStructureNV = (PFN_vkCreateAccelerationStructureNV)load(context, "vkCreateAccelerationStructureNV");
+ table->vkCreateRayTracingPipelinesNV = (PFN_vkCreateRayTracingPipelinesNV)load(context, "vkCreateRayTracingPipelinesNV");
+ table->vkDestroyAccelerationStructureNV = (PFN_vkDestroyAccelerationStructureNV)load(context, "vkDestroyAccelerationStructureNV");
+ table->vkGetAccelerationStructureHandleNV = (PFN_vkGetAccelerationStructureHandleNV)load(context, "vkGetAccelerationStructureHandleNV");
+ table->vkGetAccelerationStructureMemoryRequirementsNV = (PFN_vkGetAccelerationStructureMemoryRequirementsNV)load(context, "vkGetAccelerationStructureMemoryRequirementsNV");
+ table->vkGetRayTracingShaderGroupHandlesNV = (PFN_vkGetRayTracingShaderGroupHandlesNV)load(context, "vkGetRayTracingShaderGroupHandlesNV");
+#endif /* defined(VK_NV_ray_tracing) */
+#if defined(VK_NV_scissor_exclusive)
+ table->vkCmdSetExclusiveScissorNV = (PFN_vkCmdSetExclusiveScissorNV)load(context, "vkCmdSetExclusiveScissorNV");
+#endif /* defined(VK_NV_scissor_exclusive) */
+#if defined(VK_NV_shading_rate_image)
+ table->vkCmdBindShadingRateImageNV = (PFN_vkCmdBindShadingRateImageNV)load(context, "vkCmdBindShadingRateImageNV");
+ table->vkCmdSetCoarseSampleOrderNV = (PFN_vkCmdSetCoarseSampleOrderNV)load(context, "vkCmdSetCoarseSampleOrderNV");
+ table->vkCmdSetViewportShadingRatePaletteNV = (PFN_vkCmdSetViewportShadingRatePaletteNV)load(context, "vkCmdSetViewportShadingRatePaletteNV");
+#endif /* defined(VK_NV_shading_rate_image) */
+#if (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1))
+ table->vkGetDeviceGroupSurfacePresentModes2EXT = (PFN_vkGetDeviceGroupSurfacePresentModes2EXT)load(context, "vkGetDeviceGroupSurfacePresentModes2EXT");
+#endif /* (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1))
+ table->vkCmdPushDescriptorSetWithTemplateKHR = (PFN_vkCmdPushDescriptorSetWithTemplateKHR)load(context, "vkCmdPushDescriptorSetWithTemplateKHR");
+#endif /* (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+ table->vkGetDeviceGroupPresentCapabilitiesKHR = (PFN_vkGetDeviceGroupPresentCapabilitiesKHR)load(context, "vkGetDeviceGroupPresentCapabilitiesKHR");
+ table->vkGetDeviceGroupSurfacePresentModesKHR = (PFN_vkGetDeviceGroupSurfacePresentModesKHR)load(context, "vkGetDeviceGroupSurfacePresentModesKHR");
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+ table->vkAcquireNextImage2KHR = (PFN_vkAcquireNextImage2KHR)load(context, "vkAcquireNextImage2KHR");
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+ /* VOLK_GENERATE_LOAD_DEVICE_TABLE */
+}
+
+#ifdef __GNUC__
+# pragma GCC visibility push(hidden)
+#endif
+
+/* VOLK_GENERATE_PROTOTYPES_C */
+#if defined(VK_VERSION_1_0)
+PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
+PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
+PFN_vkAllocateMemory vkAllocateMemory;
+PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
+PFN_vkBindBufferMemory vkBindBufferMemory;
+PFN_vkBindImageMemory vkBindImageMemory;
+PFN_vkCmdBeginQuery vkCmdBeginQuery;
+PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
+PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
+PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
+PFN_vkCmdBindPipeline vkCmdBindPipeline;
+PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
+PFN_vkCmdBlitImage vkCmdBlitImage;
+PFN_vkCmdClearAttachments vkCmdClearAttachments;
+PFN_vkCmdClearColorImage vkCmdClearColorImage;
+PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
+PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
+PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
+PFN_vkCmdCopyImage vkCmdCopyImage;
+PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
+PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
+PFN_vkCmdDispatch vkCmdDispatch;
+PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
+PFN_vkCmdDraw vkCmdDraw;
+PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
+PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
+PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
+PFN_vkCmdEndQuery vkCmdEndQuery;
+PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
+PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
+PFN_vkCmdFillBuffer vkCmdFillBuffer;
+PFN_vkCmdNextSubpass vkCmdNextSubpass;
+PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
+PFN_vkCmdPushConstants vkCmdPushConstants;
+PFN_vkCmdResetEvent vkCmdResetEvent;
+PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
+PFN_vkCmdResolveImage vkCmdResolveImage;
+PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
+PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
+PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
+PFN_vkCmdSetEvent vkCmdSetEvent;
+PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
+PFN_vkCmdSetScissor vkCmdSetScissor;
+PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
+PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
+PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
+PFN_vkCmdSetViewport vkCmdSetViewport;
+PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
+PFN_vkCmdWaitEvents vkCmdWaitEvents;
+PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
+PFN_vkCreateBuffer vkCreateBuffer;
+PFN_vkCreateBufferView vkCreateBufferView;
+PFN_vkCreateCommandPool vkCreateCommandPool;
+PFN_vkCreateComputePipelines vkCreateComputePipelines;
+PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
+PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
+PFN_vkCreateDevice vkCreateDevice;
+PFN_vkCreateEvent vkCreateEvent;
+PFN_vkCreateFence vkCreateFence;
+PFN_vkCreateFramebuffer vkCreateFramebuffer;
+PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
+PFN_vkCreateImage vkCreateImage;
+PFN_vkCreateImageView vkCreateImageView;
+PFN_vkCreateInstance vkCreateInstance;
+PFN_vkCreatePipelineCache vkCreatePipelineCache;
+PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
+PFN_vkCreateQueryPool vkCreateQueryPool;
+PFN_vkCreateRenderPass vkCreateRenderPass;
+PFN_vkCreateSampler vkCreateSampler;
+PFN_vkCreateSemaphore vkCreateSemaphore;
+PFN_vkCreateShaderModule vkCreateShaderModule;
+PFN_vkDestroyBuffer vkDestroyBuffer;
+PFN_vkDestroyBufferView vkDestroyBufferView;
+PFN_vkDestroyCommandPool vkDestroyCommandPool;
+PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
+PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
+PFN_vkDestroyDevice vkDestroyDevice;
+PFN_vkDestroyEvent vkDestroyEvent;
+PFN_vkDestroyFence vkDestroyFence;
+PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
+PFN_vkDestroyImage vkDestroyImage;
+PFN_vkDestroyImageView vkDestroyImageView;
+PFN_vkDestroyInstance vkDestroyInstance;
+PFN_vkDestroyPipeline vkDestroyPipeline;
+PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
+PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
+PFN_vkDestroyQueryPool vkDestroyQueryPool;
+PFN_vkDestroyRenderPass vkDestroyRenderPass;
+PFN_vkDestroySampler vkDestroySampler;
+PFN_vkDestroySemaphore vkDestroySemaphore;
+PFN_vkDestroyShaderModule vkDestroyShaderModule;
+PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
+PFN_vkEndCommandBuffer vkEndCommandBuffer;
+PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
+PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
+PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
+PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
+PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
+PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
+PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
+PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
+PFN_vkFreeMemory vkFreeMemory;
+PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
+PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
+PFN_vkGetDeviceQueue vkGetDeviceQueue;
+PFN_vkGetEventStatus vkGetEventStatus;
+PFN_vkGetFenceStatus vkGetFenceStatus;
+PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
+PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
+PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
+PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
+PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
+PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
+PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
+PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
+PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
+PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
+PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
+PFN_vkMapMemory vkMapMemory;
+PFN_vkMergePipelineCaches vkMergePipelineCaches;
+PFN_vkQueueBindSparse vkQueueBindSparse;
+PFN_vkQueueSubmit vkQueueSubmit;
+PFN_vkQueueWaitIdle vkQueueWaitIdle;
+PFN_vkResetCommandBuffer vkResetCommandBuffer;
+PFN_vkResetCommandPool vkResetCommandPool;
+PFN_vkResetDescriptorPool vkResetDescriptorPool;
+PFN_vkResetEvent vkResetEvent;
+PFN_vkResetFences vkResetFences;
+PFN_vkSetEvent vkSetEvent;
+PFN_vkUnmapMemory vkUnmapMemory;
+PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
+PFN_vkWaitForFences vkWaitForFences;
+#endif /* defined(VK_VERSION_1_0) */
+#if defined(VK_VERSION_1_1)
+PFN_vkBindBufferMemory2 vkBindBufferMemory2;
+PFN_vkBindImageMemory2 vkBindImageMemory2;
+PFN_vkCmdDispatchBase vkCmdDispatchBase;
+PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask;
+PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate;
+PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion;
+PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate;
+PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion;
+PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion;
+PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups;
+PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2;
+PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport;
+PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures;
+PFN_vkGetDeviceQueue2 vkGetDeviceQueue2;
+PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2;
+PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2;
+PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties;
+PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties;
+PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties;
+PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2;
+PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2;
+PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2;
+PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2;
+PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2;
+PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2;
+PFN_vkTrimCommandPool vkTrimCommandPool;
+PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate;
+#endif /* defined(VK_VERSION_1_1) */
+#if defined(VK_VERSION_1_2)
+PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2;
+PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount;
+PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount;
+PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2;
+PFN_vkCmdNextSubpass2 vkCmdNextSubpass2;
+PFN_vkCreateRenderPass2 vkCreateRenderPass2;
+PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress;
+PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress;
+PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress;
+PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue;
+PFN_vkResetQueryPool vkResetQueryPool;
+PFN_vkSignalSemaphore vkSignalSemaphore;
+PFN_vkWaitSemaphores vkWaitSemaphores;
+#endif /* defined(VK_VERSION_1_2) */
+#if defined(VK_AMD_buffer_marker)
+PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD;
+#endif /* defined(VK_AMD_buffer_marker) */
+#if defined(VK_AMD_display_native_hdr)
+PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD;
+#endif /* defined(VK_AMD_display_native_hdr) */
+#if defined(VK_AMD_draw_indirect_count)
+PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD;
+PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD;
+#endif /* defined(VK_AMD_draw_indirect_count) */
+#if defined(VK_AMD_shader_info)
+PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD;
+#endif /* defined(VK_AMD_shader_info) */
+#if defined(VK_ANDROID_external_memory_android_hardware_buffer)
+PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID;
+PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID;
+#endif /* defined(VK_ANDROID_external_memory_android_hardware_buffer) */
+#if defined(VK_EXT_acquire_xlib_display)
+PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT;
+PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT;
+#endif /* defined(VK_EXT_acquire_xlib_display) */
+#if defined(VK_EXT_buffer_device_address)
+PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT;
+#endif /* defined(VK_EXT_buffer_device_address) */
+#if defined(VK_EXT_calibrated_timestamps)
+PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT;
+PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
+#endif /* defined(VK_EXT_calibrated_timestamps) */
+#if defined(VK_EXT_conditional_rendering)
+PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT;
+PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT;
+#endif /* defined(VK_EXT_conditional_rendering) */
+#if defined(VK_EXT_debug_marker)
+PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT;
+PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT;
+PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT;
+PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT;
+PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT;
+#endif /* defined(VK_EXT_debug_marker) */
+#if defined(VK_EXT_debug_report)
+PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT;
+PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT;
+PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
+#endif /* defined(VK_EXT_debug_report) */
+#if defined(VK_EXT_debug_utils)
+PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT;
+PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT;
+PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT;
+PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT;
+PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
+PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT;
+PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT;
+PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT;
+PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT;
+PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT;
+PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT;
+#endif /* defined(VK_EXT_debug_utils) */
+#if defined(VK_EXT_direct_mode_display)
+PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT;
+#endif /* defined(VK_EXT_direct_mode_display) */
+#if defined(VK_EXT_discard_rectangles)
+PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT;
+#endif /* defined(VK_EXT_discard_rectangles) */
+#if defined(VK_EXT_display_control)
+PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT;
+PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT;
+PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT;
+PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT;
+#endif /* defined(VK_EXT_display_control) */
+#if defined(VK_EXT_display_surface_counter)
+PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+#endif /* defined(VK_EXT_display_surface_counter) */
+#if defined(VK_EXT_external_memory_host)
+PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT;
+#endif /* defined(VK_EXT_external_memory_host) */
+#if defined(VK_EXT_full_screen_exclusive)
+PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT;
+PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT;
+PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT;
+#endif /* defined(VK_EXT_full_screen_exclusive) */
+#if defined(VK_EXT_hdr_metadata)
+PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT;
+#endif /* defined(VK_EXT_hdr_metadata) */
+#if defined(VK_EXT_headless_surface)
+PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT;
+#endif /* defined(VK_EXT_headless_surface) */
+#if defined(VK_EXT_host_query_reset)
+PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT;
+#endif /* defined(VK_EXT_host_query_reset) */
+#if defined(VK_EXT_image_drm_format_modifier)
+PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT;
+#endif /* defined(VK_EXT_image_drm_format_modifier) */
+#if defined(VK_EXT_line_rasterization)
+PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT;
+#endif /* defined(VK_EXT_line_rasterization) */
+#if defined(VK_EXT_metal_surface)
+PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT;
+#endif /* defined(VK_EXT_metal_surface) */
+#if defined(VK_EXT_sample_locations)
+PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT;
+PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT;
+#endif /* defined(VK_EXT_sample_locations) */
+#if defined(VK_EXT_tooling_info)
+PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT;
+#endif /* defined(VK_EXT_tooling_info) */
+#if defined(VK_EXT_transform_feedback)
+PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT;
+PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT;
+PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT;
+PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT;
+PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT;
+PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT;
+#endif /* defined(VK_EXT_transform_feedback) */
+#if defined(VK_EXT_validation_cache)
+PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT;
+PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT;
+PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT;
+PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT;
+#endif /* defined(VK_EXT_validation_cache) */
+#if defined(VK_FUCHSIA_imagepipe_surface)
+PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA;
+#endif /* defined(VK_FUCHSIA_imagepipe_surface) */
+#if defined(VK_GGP_stream_descriptor_surface)
+PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP;
+#endif /* defined(VK_GGP_stream_descriptor_surface) */
+#if defined(VK_GOOGLE_display_timing)
+PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE;
+PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE;
+#endif /* defined(VK_GOOGLE_display_timing) */
+#if defined(VK_INTEL_performance_query)
+PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL;
+PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL;
+PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL;
+PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL;
+PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL;
+PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL;
+PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL;
+PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL;
+PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL;
+#endif /* defined(VK_INTEL_performance_query) */
+#if defined(VK_KHR_android_surface)
+PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR;
+#endif /* defined(VK_KHR_android_surface) */
+#if defined(VK_KHR_bind_memory2)
+PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR;
+PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR;
+#endif /* defined(VK_KHR_bind_memory2) */
+#if defined(VK_KHR_buffer_device_address)
+PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR;
+PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR;
+PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR;
+#endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_create_renderpass2)
+PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR;
+PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR;
+PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR;
+PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR;
+#endif /* defined(VK_KHR_create_renderpass2) */
+#if defined(VK_KHR_descriptor_update_template)
+PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR;
+PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR;
+PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR;
+#endif /* defined(VK_KHR_descriptor_update_template) */
+#if defined(VK_KHR_device_group)
+PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR;
+PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR;
+PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR;
+#endif /* defined(VK_KHR_device_group) */
+#if defined(VK_KHR_device_group_creation)
+PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR;
+#endif /* defined(VK_KHR_device_group_creation) */
+#if defined(VK_KHR_display)
+PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR;
+PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
+PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
+PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
+PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
+PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
+#endif /* defined(VK_KHR_display) */
+#if defined(VK_KHR_display_swapchain)
+PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR;
+#endif /* defined(VK_KHR_display_swapchain) */
+#if defined(VK_KHR_draw_indirect_count)
+PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR;
+PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR;
+#endif /* defined(VK_KHR_draw_indirect_count) */
+#if defined(VK_KHR_external_fence_capabilities)
+PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR;
+#endif /* defined(VK_KHR_external_fence_capabilities) */
+#if defined(VK_KHR_external_fence_fd)
+PFN_vkGetFenceFdKHR vkGetFenceFdKHR;
+PFN_vkImportFenceFdKHR vkImportFenceFdKHR;
+#endif /* defined(VK_KHR_external_fence_fd) */
+#if defined(VK_KHR_external_fence_win32)
+PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR;
+PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR;
+#endif /* defined(VK_KHR_external_fence_win32) */
+#if defined(VK_KHR_external_memory_capabilities)
+PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_capabilities) */
+#if defined(VK_KHR_external_memory_fd)
+PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR;
+PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_fd) */
+#if defined(VK_KHR_external_memory_win32)
+PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR;
+PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_win32) */
+#if defined(VK_KHR_external_semaphore_capabilities)
+PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+#endif /* defined(VK_KHR_external_semaphore_capabilities) */
+#if defined(VK_KHR_external_semaphore_fd)
+PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR;
+PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR;
+#endif /* defined(VK_KHR_external_semaphore_fd) */
+#if defined(VK_KHR_external_semaphore_win32)
+PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR;
+PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR;
+#endif /* defined(VK_KHR_external_semaphore_win32) */
+#if defined(VK_KHR_get_display_properties2)
+PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR;
+PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR;
+PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR;
+#endif /* defined(VK_KHR_get_display_properties2) */
+#if defined(VK_KHR_get_memory_requirements2)
+PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
+PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
+PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR;
+#endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_get_physical_device_properties2)
+PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR;
+PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR;
+PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR;
+PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR;
+PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+#endif /* defined(VK_KHR_get_physical_device_properties2) */
+#if defined(VK_KHR_get_surface_capabilities2)
+PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
+#endif /* defined(VK_KHR_get_surface_capabilities2) */
+#if defined(VK_KHR_maintenance1)
+PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
+#endif /* defined(VK_KHR_maintenance1) */
+#if defined(VK_KHR_maintenance3)
+PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR;
+#endif /* defined(VK_KHR_maintenance3) */
+#if defined(VK_KHR_performance_query)
+PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR;
+PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
+PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
+PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR;
+#endif /* defined(VK_KHR_performance_query) */
+#if defined(VK_KHR_pipeline_executable_properties)
+PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR;
+PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR;
+PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR;
+#endif /* defined(VK_KHR_pipeline_executable_properties) */
+#if defined(VK_KHR_push_descriptor)
+PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR;
+#endif /* defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_sampler_ycbcr_conversion)
+PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR;
+PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR;
+#endif /* defined(VK_KHR_sampler_ycbcr_conversion) */
+#if defined(VK_KHR_shared_presentable_image)
+PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR;
+#endif /* defined(VK_KHR_shared_presentable_image) */
+#if defined(VK_KHR_surface)
+PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
+PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
+PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
+PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
+#endif /* defined(VK_KHR_surface) */
+#if defined(VK_KHR_swapchain)
+PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
+PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
+PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
+PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
+PFN_vkQueuePresentKHR vkQueuePresentKHR;
+#endif /* defined(VK_KHR_swapchain) */
+#if defined(VK_KHR_timeline_semaphore)
+PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR;
+PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR;
+PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR;
+#endif /* defined(VK_KHR_timeline_semaphore) */
+#if defined(VK_KHR_wayland_surface)
+PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR;
+PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+#endif /* defined(VK_KHR_wayland_surface) */
+#if defined(VK_KHR_win32_surface)
+PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR;
+PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR;
+#endif /* defined(VK_KHR_win32_surface) */
+#if defined(VK_KHR_xcb_surface)
+PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
+PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR;
+#endif /* defined(VK_KHR_xcb_surface) */
+#if defined(VK_KHR_xlib_surface)
+PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
+PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR;
+#endif /* defined(VK_KHR_xlib_surface) */
+#if defined(VK_MVK_ios_surface)
+PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK;
+#endif /* defined(VK_MVK_ios_surface) */
+#if defined(VK_MVK_macos_surface)
+PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK;
+#endif /* defined(VK_MVK_macos_surface) */
+#if defined(VK_NN_vi_surface)
+PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN;
+#endif /* defined(VK_NN_vi_surface) */
+#if defined(VK_NVX_device_generated_commands)
+PFN_vkCmdProcessCommandsNVX vkCmdProcessCommandsNVX;
+PFN_vkCmdReserveSpaceForCommandsNVX vkCmdReserveSpaceForCommandsNVX;
+PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX;
+PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX;
+PFN_vkDestroyIndirectCommandsLayoutNVX vkDestroyIndirectCommandsLayoutNVX;
+PFN_vkDestroyObjectTableNVX vkDestroyObjectTableNVX;
+PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX;
+PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX;
+#endif /* defined(VK_NVX_device_generated_commands) */
+#if defined(VK_NVX_image_view_handle)
+PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX;
+#endif /* defined(VK_NVX_image_view_handle) */
+#if defined(VK_NV_clip_space_w_scaling)
+PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV;
+#endif /* defined(VK_NV_clip_space_w_scaling) */
+#if defined(VK_NV_cooperative_matrix)
+PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV;
+#endif /* defined(VK_NV_cooperative_matrix) */
+#if defined(VK_NV_coverage_reduction_mode)
+PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
+#endif /* defined(VK_NV_coverage_reduction_mode) */
+#if defined(VK_NV_device_diagnostic_checkpoints)
+PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV;
+PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV;
+#endif /* defined(VK_NV_device_diagnostic_checkpoints) */
+#if defined(VK_NV_external_memory_capabilities)
+PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+#endif /* defined(VK_NV_external_memory_capabilities) */
+#if defined(VK_NV_external_memory_win32)
+PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV;
+#endif /* defined(VK_NV_external_memory_win32) */
+#if defined(VK_NV_mesh_shader)
+PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV;
+PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV;
+PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV;
+#endif /* defined(VK_NV_mesh_shader) */
+#if defined(VK_NV_ray_tracing)
+PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV;
+PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV;
+PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV;
+PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV;
+PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV;
+PFN_vkCompileDeferredNV vkCompileDeferredNV;
+PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV;
+PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV;
+PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV;
+PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV;
+PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV;
+PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV;
+#endif /* defined(VK_NV_ray_tracing) */
+#if defined(VK_NV_scissor_exclusive)
+PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV;
+#endif /* defined(VK_NV_scissor_exclusive) */
+#if defined(VK_NV_shading_rate_image)
+PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV;
+PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV;
+PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV;
+#endif /* defined(VK_NV_shading_rate_image) */
+#if (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1))
+PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT;
+#endif /* (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1))
+PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR;
+#endif /* (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR;
+PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR;
+PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR;
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR;
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+/* VOLK_GENERATE_PROTOTYPES_C */
+
+#ifdef __GNUC__
+# pragma GCC visibility pop
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+/* clang-format on */
diff --git a/native/cocos/renderer/gfx-vulkan/volk.h b/native/cocos/renderer/gfx-vulkan/volk.h
new file mode 100644
index 0000000000..b8777c57b8
--- /dev/null
+++ b/native/cocos/renderer/gfx-vulkan/volk.h
@@ -0,0 +1,1139 @@
+/**
+ * volk
+ *
+ * Copyright (C) 2018-2019, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at https://github.com/zeux/volk
+ *
+ * This library is distributed under the MIT License. See notice at the end of this file.
+ */
+/* clang-format off */
+#ifndef VOLK_H_
+#define VOLK_H_
+
+#if defined(VULKAN_H_) && !defined(VK_NO_PROTOTYPES)
+# error To use volk, you need to define VK_NO_PROTOTYPES before including vulkan.h
+#endif
+
+/* VOLK_GENERATE_VERSION_DEFINE */
+#define VOLK_HEADER_VERSION 131
+/* VOLK_GENERATE_VERSION_DEFINE */
+
+#ifndef VK_NO_PROTOTYPES
+# define VK_NO_PROTOTYPES
+#endif
+
+#ifndef VULKAN_H_
+# ifdef VOLK_VULKAN_H_PATH
+# include VOLK_VULKAN_H_PATH
+# elif defined(VK_USE_PLATFORM_WIN32_KHR)
+# include
+# include
+
+ /* When VK_USE_PLATFORM_WIN32_KHR is defined, instead of including vulkan.h directly, we include individual parts of the SDK
+ * This is necessary to avoid including which is very heavy - it takes 200ms to parse without WIN32_LEAN_AND_MEAN
+ * and 100ms to parse with it. vulkan_win32.h only needs a few symbols that are easy to redefine ourselves.
+ */
+ typedef unsigned long DWORD;
+ typedef const wchar_t* LPCWSTR;
+ typedef void* HANDLE;
+ typedef struct HINSTANCE__* HINSTANCE;
+ typedef struct HWND__* HWND;
+ typedef struct HMONITOR__* HMONITOR;
+ typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES;
+
+# include
+# else
+# include
+# endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct VolkDeviceTable;
+
+/**
+ * Initialize library by loading Vulkan loader; call this function before creating the Vulkan instance.
+ *
+ * Returns VK_SUCCESS on success and VK_ERROR_INITIALIZATION_FAILED otherwise.
+ */
+VkResult volkInitialize(void);
+
+/**
+ * Initialize library by providing a custom handler to load global symbols.
+ *
+ * This function can be used instead of volkInitialize.
+ * The handler function pointer will be asked to load global Vulkan symbols which require no instance
+ * (such as vkCreateInstance, vkEnumerateInstance* and vkEnumerateInstanceVersion if available).
+ */
+void volkInitializeCustom(PFN_vkGetInstanceProcAddr handler);
+
+/**
+ * Get Vulkan instance version supported by the Vulkan loader, or 0 if Vulkan isn't supported
+ *
+ * Returns 0 if volkInitialize wasn't called or failed.
+ */
+uint32_t volkGetInstanceVersion(void);
+
+/**
+ * Load global function pointers using application-created VkInstance; call this function after creating the Vulkan instance.
+ */
+void volkLoadInstance(VkInstance instance);
+
+/**
+ * Load global function pointers using application-created VkDevice; call this function after creating the Vulkan device.
+ *
+ * Note: this is not suitable for applications that want to use multiple VkDevice objects concurrently.
+ */
+void volkLoadDevice(VkDevice device);
+
+/**
+ * Return last VkInstance for which global function pointers have been loaded via volkLoadInstance(),
+ * or VK_NULL_HANDLE if volkLoadInstance() has not been called.
+ */
+VkInstance volkGetLoadedInstance();
+
+/**
+ * Return last VkDevice for which global function pointers have been loaded via volkLoadDevice(),
+ * or VK_NULL_HANDLE if volkLoadDevice() has not been called.
+ */
+VkDevice volkGetLoadedDevice();
+
+/**
+ * Load function pointers using application-created VkDevice into a table.
+ * Application should use function pointers from that table instead of using global function pointers.
+ */
+void volkLoadDeviceTable(struct VolkDeviceTable* table, VkDevice device);
+
+/**
+ * Device-specific function pointer table
+ */
+struct VolkDeviceTable
+{
+ /* VOLK_GENERATE_DEVICE_TABLE */
+#if defined(VK_VERSION_1_0)
+ PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
+ PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
+ PFN_vkAllocateMemory vkAllocateMemory;
+ PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
+ PFN_vkBindBufferMemory vkBindBufferMemory;
+ PFN_vkBindImageMemory vkBindImageMemory;
+ PFN_vkCmdBeginQuery vkCmdBeginQuery;
+ PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
+ PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
+ PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
+ PFN_vkCmdBindPipeline vkCmdBindPipeline;
+ PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
+ PFN_vkCmdBlitImage vkCmdBlitImage;
+ PFN_vkCmdClearAttachments vkCmdClearAttachments;
+ PFN_vkCmdClearColorImage vkCmdClearColorImage;
+ PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
+ PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
+ PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
+ PFN_vkCmdCopyImage vkCmdCopyImage;
+ PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
+ PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
+ PFN_vkCmdDispatch vkCmdDispatch;
+ PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
+ PFN_vkCmdDraw vkCmdDraw;
+ PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
+ PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
+ PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
+ PFN_vkCmdEndQuery vkCmdEndQuery;
+ PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
+ PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
+ PFN_vkCmdFillBuffer vkCmdFillBuffer;
+ PFN_vkCmdNextSubpass vkCmdNextSubpass;
+ PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
+ PFN_vkCmdPushConstants vkCmdPushConstants;
+ PFN_vkCmdResetEvent vkCmdResetEvent;
+ PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
+ PFN_vkCmdResolveImage vkCmdResolveImage;
+ PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
+ PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
+ PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
+ PFN_vkCmdSetEvent vkCmdSetEvent;
+ PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
+ PFN_vkCmdSetScissor vkCmdSetScissor;
+ PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
+ PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
+ PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
+ PFN_vkCmdSetViewport vkCmdSetViewport;
+ PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
+ PFN_vkCmdWaitEvents vkCmdWaitEvents;
+ PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
+ PFN_vkCreateBuffer vkCreateBuffer;
+ PFN_vkCreateBufferView vkCreateBufferView;
+ PFN_vkCreateCommandPool vkCreateCommandPool;
+ PFN_vkCreateComputePipelines vkCreateComputePipelines;
+ PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
+ PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
+ PFN_vkCreateEvent vkCreateEvent;
+ PFN_vkCreateFence vkCreateFence;
+ PFN_vkCreateFramebuffer vkCreateFramebuffer;
+ PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
+ PFN_vkCreateImage vkCreateImage;
+ PFN_vkCreateImageView vkCreateImageView;
+ PFN_vkCreatePipelineCache vkCreatePipelineCache;
+ PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
+ PFN_vkCreateQueryPool vkCreateQueryPool;
+ PFN_vkCreateRenderPass vkCreateRenderPass;
+ PFN_vkCreateSampler vkCreateSampler;
+ PFN_vkCreateSemaphore vkCreateSemaphore;
+ PFN_vkCreateShaderModule vkCreateShaderModule;
+ PFN_vkDestroyBuffer vkDestroyBuffer;
+ PFN_vkDestroyBufferView vkDestroyBufferView;
+ PFN_vkDestroyCommandPool vkDestroyCommandPool;
+ PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
+ PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
+ PFN_vkDestroyDevice vkDestroyDevice;
+ PFN_vkDestroyEvent vkDestroyEvent;
+ PFN_vkDestroyFence vkDestroyFence;
+ PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
+ PFN_vkDestroyImage vkDestroyImage;
+ PFN_vkDestroyImageView vkDestroyImageView;
+ PFN_vkDestroyPipeline vkDestroyPipeline;
+ PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
+ PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
+ PFN_vkDestroyQueryPool vkDestroyQueryPool;
+ PFN_vkDestroyRenderPass vkDestroyRenderPass;
+ PFN_vkDestroySampler vkDestroySampler;
+ PFN_vkDestroySemaphore vkDestroySemaphore;
+ PFN_vkDestroyShaderModule vkDestroyShaderModule;
+ PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
+ PFN_vkEndCommandBuffer vkEndCommandBuffer;
+ PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
+ PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
+ PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
+ PFN_vkFreeMemory vkFreeMemory;
+ PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+ PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
+ PFN_vkGetDeviceQueue vkGetDeviceQueue;
+ PFN_vkGetEventStatus vkGetEventStatus;
+ PFN_vkGetFenceStatus vkGetFenceStatus;
+ PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+ PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
+ PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
+ PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
+ PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
+ PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
+ PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
+ PFN_vkMapMemory vkMapMemory;
+ PFN_vkMergePipelineCaches vkMergePipelineCaches;
+ PFN_vkQueueBindSparse vkQueueBindSparse;
+ PFN_vkQueueSubmit vkQueueSubmit;
+ PFN_vkQueueWaitIdle vkQueueWaitIdle;
+ PFN_vkResetCommandBuffer vkResetCommandBuffer;
+ PFN_vkResetCommandPool vkResetCommandPool;
+ PFN_vkResetDescriptorPool vkResetDescriptorPool;
+ PFN_vkResetEvent vkResetEvent;
+ PFN_vkResetFences vkResetFences;
+ PFN_vkSetEvent vkSetEvent;
+ PFN_vkUnmapMemory vkUnmapMemory;
+ PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
+ PFN_vkWaitForFences vkWaitForFences;
+#endif /* defined(VK_VERSION_1_0) */
+#if defined(VK_VERSION_1_1)
+ PFN_vkBindBufferMemory2 vkBindBufferMemory2;
+ PFN_vkBindImageMemory2 vkBindImageMemory2;
+ PFN_vkCmdDispatchBase vkCmdDispatchBase;
+ PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask;
+ PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate;
+ PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion;
+ PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate;
+ PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion;
+ PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2;
+ PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport;
+ PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures;
+ PFN_vkGetDeviceQueue2 vkGetDeviceQueue2;
+ PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2;
+ PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2;
+ PFN_vkTrimCommandPool vkTrimCommandPool;
+ PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate;
+#endif /* defined(VK_VERSION_1_1) */
+#if defined(VK_VERSION_1_2)
+ PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2;
+ PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount;
+ PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount;
+ PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2;
+ PFN_vkCmdNextSubpass2 vkCmdNextSubpass2;
+ PFN_vkCreateRenderPass2 vkCreateRenderPass2;
+ PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress;
+ PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress;
+ PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress;
+ PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue;
+ PFN_vkResetQueryPool vkResetQueryPool;
+ PFN_vkSignalSemaphore vkSignalSemaphore;
+ PFN_vkWaitSemaphores vkWaitSemaphores;
+#endif /* defined(VK_VERSION_1_2) */
+#if defined(VK_AMD_buffer_marker)
+ PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD;
+#endif /* defined(VK_AMD_buffer_marker) */
+#if defined(VK_AMD_display_native_hdr)
+ PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD;
+#endif /* defined(VK_AMD_display_native_hdr) */
+#if defined(VK_AMD_draw_indirect_count)
+ PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD;
+ PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD;
+#endif /* defined(VK_AMD_draw_indirect_count) */
+#if defined(VK_AMD_shader_info)
+ PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD;
+#endif /* defined(VK_AMD_shader_info) */
+#if defined(VK_ANDROID_external_memory_android_hardware_buffer)
+ PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID;
+ PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID;
+#endif /* defined(VK_ANDROID_external_memory_android_hardware_buffer) */
+#if defined(VK_EXT_buffer_device_address)
+ PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT;
+#endif /* defined(VK_EXT_buffer_device_address) */
+#if defined(VK_EXT_calibrated_timestamps)
+ PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT;
+#endif /* defined(VK_EXT_calibrated_timestamps) */
+#if defined(VK_EXT_conditional_rendering)
+ PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT;
+ PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT;
+#endif /* defined(VK_EXT_conditional_rendering) */
+#if defined(VK_EXT_debug_marker)
+ PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT;
+ PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT;
+ PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT;
+ PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT;
+ PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT;
+#endif /* defined(VK_EXT_debug_marker) */
+#if defined(VK_EXT_discard_rectangles)
+ PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT;
+#endif /* defined(VK_EXT_discard_rectangles) */
+#if defined(VK_EXT_display_control)
+ PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT;
+ PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT;
+ PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT;
+ PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT;
+#endif /* defined(VK_EXT_display_control) */
+#if defined(VK_EXT_external_memory_host)
+ PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT;
+#endif /* defined(VK_EXT_external_memory_host) */
+#if defined(VK_EXT_full_screen_exclusive)
+ PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT;
+ PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT;
+#endif /* defined(VK_EXT_full_screen_exclusive) */
+#if defined(VK_EXT_hdr_metadata)
+ PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT;
+#endif /* defined(VK_EXT_hdr_metadata) */
+#if defined(VK_EXT_host_query_reset)
+ PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT;
+#endif /* defined(VK_EXT_host_query_reset) */
+#if defined(VK_EXT_image_drm_format_modifier)
+ PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT;
+#endif /* defined(VK_EXT_image_drm_format_modifier) */
+#if defined(VK_EXT_line_rasterization)
+ PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT;
+#endif /* defined(VK_EXT_line_rasterization) */
+#if defined(VK_EXT_sample_locations)
+ PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT;
+#endif /* defined(VK_EXT_sample_locations) */
+#if defined(VK_EXT_transform_feedback)
+ PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT;
+ PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT;
+ PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT;
+ PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT;
+ PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT;
+ PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT;
+#endif /* defined(VK_EXT_transform_feedback) */
+#if defined(VK_EXT_validation_cache)
+ PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT;
+ PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT;
+ PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT;
+ PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT;
+#endif /* defined(VK_EXT_validation_cache) */
+#if defined(VK_GOOGLE_display_timing)
+ PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE;
+ PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE;
+#endif /* defined(VK_GOOGLE_display_timing) */
+#if defined(VK_INTEL_performance_query)
+ PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL;
+ PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL;
+ PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL;
+ PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL;
+ PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL;
+ PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL;
+ PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL;
+ PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL;
+ PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL;
+#endif /* defined(VK_INTEL_performance_query) */
+#if defined(VK_KHR_bind_memory2)
+ PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR;
+ PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR;
+#endif /* defined(VK_KHR_bind_memory2) */
+#if defined(VK_KHR_buffer_device_address)
+ PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR;
+ PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR;
+ PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR;
+#endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_create_renderpass2)
+ PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR;
+ PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR;
+ PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR;
+ PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR;
+#endif /* defined(VK_KHR_create_renderpass2) */
+#if defined(VK_KHR_descriptor_update_template)
+ PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR;
+ PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR;
+ PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR;
+#endif /* defined(VK_KHR_descriptor_update_template) */
+#if defined(VK_KHR_device_group)
+ PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR;
+ PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR;
+ PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR;
+#endif /* defined(VK_KHR_device_group) */
+#if defined(VK_KHR_display_swapchain)
+ PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR;
+#endif /* defined(VK_KHR_display_swapchain) */
+#if defined(VK_KHR_draw_indirect_count)
+ PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR;
+ PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR;
+#endif /* defined(VK_KHR_draw_indirect_count) */
+#if defined(VK_KHR_external_fence_fd)
+ PFN_vkGetFenceFdKHR vkGetFenceFdKHR;
+ PFN_vkImportFenceFdKHR vkImportFenceFdKHR;
+#endif /* defined(VK_KHR_external_fence_fd) */
+#if defined(VK_KHR_external_fence_win32)
+ PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR;
+ PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR;
+#endif /* defined(VK_KHR_external_fence_win32) */
+#if defined(VK_KHR_external_memory_fd)
+ PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR;
+ PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_fd) */
+#if defined(VK_KHR_external_memory_win32)
+ PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR;
+ PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_win32) */
+#if defined(VK_KHR_external_semaphore_fd)
+ PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR;
+ PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR;
+#endif /* defined(VK_KHR_external_semaphore_fd) */
+#if defined(VK_KHR_external_semaphore_win32)
+ PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR;
+ PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR;
+#endif /* defined(VK_KHR_external_semaphore_win32) */
+#if defined(VK_KHR_get_memory_requirements2)
+ PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
+ PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
+ PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR;
+#endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_maintenance1)
+ PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
+#endif /* defined(VK_KHR_maintenance1) */
+#if defined(VK_KHR_maintenance3)
+ PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR;
+#endif /* defined(VK_KHR_maintenance3) */
+#if defined(VK_KHR_performance_query)
+ PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR;
+ PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR;
+#endif /* defined(VK_KHR_performance_query) */
+#if defined(VK_KHR_pipeline_executable_properties)
+ PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR;
+ PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR;
+ PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR;
+#endif /* defined(VK_KHR_pipeline_executable_properties) */
+#if defined(VK_KHR_push_descriptor)
+ PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR;
+#endif /* defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_sampler_ycbcr_conversion)
+ PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR;
+ PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR;
+#endif /* defined(VK_KHR_sampler_ycbcr_conversion) */
+#if defined(VK_KHR_shared_presentable_image)
+ PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR;
+#endif /* defined(VK_KHR_shared_presentable_image) */
+#if defined(VK_KHR_swapchain)
+ PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
+ PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
+ PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
+ PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
+ PFN_vkQueuePresentKHR vkQueuePresentKHR;
+#endif /* defined(VK_KHR_swapchain) */
+#if defined(VK_KHR_timeline_semaphore)
+ PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR;
+ PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR;
+ PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR;
+#endif /* defined(VK_KHR_timeline_semaphore) */
+#if defined(VK_NVX_device_generated_commands)
+ PFN_vkCmdProcessCommandsNVX vkCmdProcessCommandsNVX;
+ PFN_vkCmdReserveSpaceForCommandsNVX vkCmdReserveSpaceForCommandsNVX;
+ PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX;
+ PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX;
+ PFN_vkDestroyIndirectCommandsLayoutNVX vkDestroyIndirectCommandsLayoutNVX;
+ PFN_vkDestroyObjectTableNVX vkDestroyObjectTableNVX;
+ PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX;
+ PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX;
+#endif /* defined(VK_NVX_device_generated_commands) */
+#if defined(VK_NVX_image_view_handle)
+ PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX;
+#endif /* defined(VK_NVX_image_view_handle) */
+#if defined(VK_NV_clip_space_w_scaling)
+ PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV;
+#endif /* defined(VK_NV_clip_space_w_scaling) */
+#if defined(VK_NV_device_diagnostic_checkpoints)
+ PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV;
+ PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV;
+#endif /* defined(VK_NV_device_diagnostic_checkpoints) */
+#if defined(VK_NV_external_memory_win32)
+ PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV;
+#endif /* defined(VK_NV_external_memory_win32) */
+#if defined(VK_NV_mesh_shader)
+ PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV;
+ PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV;
+ PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV;
+#endif /* defined(VK_NV_mesh_shader) */
+#if defined(VK_NV_ray_tracing)
+ PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV;
+ PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV;
+ PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV;
+ PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV;
+ PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV;
+ PFN_vkCompileDeferredNV vkCompileDeferredNV;
+ PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV;
+ PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV;
+ PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV;
+ PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV;
+ PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV;
+ PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV;
+#endif /* defined(VK_NV_ray_tracing) */
+#if defined(VK_NV_scissor_exclusive)
+ PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV;
+#endif /* defined(VK_NV_scissor_exclusive) */
+#if defined(VK_NV_shading_rate_image)
+ PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV;
+ PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV;
+ PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV;
+#endif /* defined(VK_NV_shading_rate_image) */
+#if (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1))
+ PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT;
+#endif /* (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1))
+ PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR;
+#endif /* (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+ PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR;
+ PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR;
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+ PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR;
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+ /* VOLK_GENERATE_DEVICE_TABLE */
+};
+
+/* VOLK_GENERATE_PROTOTYPES_H */
+#if defined(VK_VERSION_1_0)
+extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
+extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
+extern PFN_vkAllocateMemory vkAllocateMemory;
+extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
+extern PFN_vkBindBufferMemory vkBindBufferMemory;
+extern PFN_vkBindImageMemory vkBindImageMemory;
+extern PFN_vkCmdBeginQuery vkCmdBeginQuery;
+extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
+extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
+extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
+extern PFN_vkCmdBindPipeline vkCmdBindPipeline;
+extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
+extern PFN_vkCmdBlitImage vkCmdBlitImage;
+extern PFN_vkCmdClearAttachments vkCmdClearAttachments;
+extern PFN_vkCmdClearColorImage vkCmdClearColorImage;
+extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
+extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
+extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
+extern PFN_vkCmdCopyImage vkCmdCopyImage;
+extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
+extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
+extern PFN_vkCmdDispatch vkCmdDispatch;
+extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
+extern PFN_vkCmdDraw vkCmdDraw;
+extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
+extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
+extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
+extern PFN_vkCmdEndQuery vkCmdEndQuery;
+extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
+extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
+extern PFN_vkCmdFillBuffer vkCmdFillBuffer;
+extern PFN_vkCmdNextSubpass vkCmdNextSubpass;
+extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
+extern PFN_vkCmdPushConstants vkCmdPushConstants;
+extern PFN_vkCmdResetEvent vkCmdResetEvent;
+extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
+extern PFN_vkCmdResolveImage vkCmdResolveImage;
+extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
+extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
+extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
+extern PFN_vkCmdSetEvent vkCmdSetEvent;
+extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
+extern PFN_vkCmdSetScissor vkCmdSetScissor;
+extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
+extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
+extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
+extern PFN_vkCmdSetViewport vkCmdSetViewport;
+extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
+extern PFN_vkCmdWaitEvents vkCmdWaitEvents;
+extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
+extern PFN_vkCreateBuffer vkCreateBuffer;
+extern PFN_vkCreateBufferView vkCreateBufferView;
+extern PFN_vkCreateCommandPool vkCreateCommandPool;
+extern PFN_vkCreateComputePipelines vkCreateComputePipelines;
+extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
+extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
+extern PFN_vkCreateDevice vkCreateDevice;
+extern PFN_vkCreateEvent vkCreateEvent;
+extern PFN_vkCreateFence vkCreateFence;
+extern PFN_vkCreateFramebuffer vkCreateFramebuffer;
+extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
+extern PFN_vkCreateImage vkCreateImage;
+extern PFN_vkCreateImageView vkCreateImageView;
+extern PFN_vkCreateInstance vkCreateInstance;
+extern PFN_vkCreatePipelineCache vkCreatePipelineCache;
+extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
+extern PFN_vkCreateQueryPool vkCreateQueryPool;
+extern PFN_vkCreateRenderPass vkCreateRenderPass;
+extern PFN_vkCreateSampler vkCreateSampler;
+extern PFN_vkCreateSemaphore vkCreateSemaphore;
+extern PFN_vkCreateShaderModule vkCreateShaderModule;
+extern PFN_vkDestroyBuffer vkDestroyBuffer;
+extern PFN_vkDestroyBufferView vkDestroyBufferView;
+extern PFN_vkDestroyCommandPool vkDestroyCommandPool;
+extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
+extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
+extern PFN_vkDestroyDevice vkDestroyDevice;
+extern PFN_vkDestroyEvent vkDestroyEvent;
+extern PFN_vkDestroyFence vkDestroyFence;
+extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
+extern PFN_vkDestroyImage vkDestroyImage;
+extern PFN_vkDestroyImageView vkDestroyImageView;
+extern PFN_vkDestroyInstance vkDestroyInstance;
+extern PFN_vkDestroyPipeline vkDestroyPipeline;
+extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
+extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
+extern PFN_vkDestroyQueryPool vkDestroyQueryPool;
+extern PFN_vkDestroyRenderPass vkDestroyRenderPass;
+extern PFN_vkDestroySampler vkDestroySampler;
+extern PFN_vkDestroySemaphore vkDestroySemaphore;
+extern PFN_vkDestroyShaderModule vkDestroyShaderModule;
+extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
+extern PFN_vkEndCommandBuffer vkEndCommandBuffer;
+extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
+extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
+extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
+extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
+extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
+extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
+extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
+extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
+extern PFN_vkFreeMemory vkFreeMemory;
+extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
+extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
+extern PFN_vkGetDeviceQueue vkGetDeviceQueue;
+extern PFN_vkGetEventStatus vkGetEventStatus;
+extern PFN_vkGetFenceStatus vkGetFenceStatus;
+extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
+extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
+extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
+extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
+extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
+extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
+extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
+extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
+extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
+extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
+extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
+extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
+extern PFN_vkMapMemory vkMapMemory;
+extern PFN_vkMergePipelineCaches vkMergePipelineCaches;
+extern PFN_vkQueueBindSparse vkQueueBindSparse;
+extern PFN_vkQueueSubmit vkQueueSubmit;
+extern PFN_vkQueueWaitIdle vkQueueWaitIdle;
+extern PFN_vkResetCommandBuffer vkResetCommandBuffer;
+extern PFN_vkResetCommandPool vkResetCommandPool;
+extern PFN_vkResetDescriptorPool vkResetDescriptorPool;
+extern PFN_vkResetEvent vkResetEvent;
+extern PFN_vkResetFences vkResetFences;
+extern PFN_vkSetEvent vkSetEvent;
+extern PFN_vkUnmapMemory vkUnmapMemory;
+extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
+extern PFN_vkWaitForFences vkWaitForFences;
+#endif /* defined(VK_VERSION_1_0) */
+#if defined(VK_VERSION_1_1)
+extern PFN_vkBindBufferMemory2 vkBindBufferMemory2;
+extern PFN_vkBindImageMemory2 vkBindImageMemory2;
+extern PFN_vkCmdDispatchBase vkCmdDispatchBase;
+extern PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask;
+extern PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate;
+extern PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion;
+extern PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate;
+extern PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion;
+extern PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion;
+extern PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups;
+extern PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2;
+extern PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport;
+extern PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures;
+extern PFN_vkGetDeviceQueue2 vkGetDeviceQueue2;
+extern PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2;
+extern PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2;
+extern PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties;
+extern PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties;
+extern PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties;
+extern PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2;
+extern PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2;
+extern PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2;
+extern PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2;
+extern PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2;
+extern PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2;
+extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2;
+extern PFN_vkTrimCommandPool vkTrimCommandPool;
+extern PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate;
+#endif /* defined(VK_VERSION_1_1) */
+#if defined(VK_VERSION_1_2)
+extern PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2;
+extern PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount;
+extern PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount;
+extern PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2;
+extern PFN_vkCmdNextSubpass2 vkCmdNextSubpass2;
+extern PFN_vkCreateRenderPass2 vkCreateRenderPass2;
+extern PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress;
+extern PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress;
+extern PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress;
+extern PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue;
+extern PFN_vkResetQueryPool vkResetQueryPool;
+extern PFN_vkSignalSemaphore vkSignalSemaphore;
+extern PFN_vkWaitSemaphores vkWaitSemaphores;
+#endif /* defined(VK_VERSION_1_2) */
+#if defined(VK_AMD_buffer_marker)
+extern PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD;
+#endif /* defined(VK_AMD_buffer_marker) */
+#if defined(VK_AMD_display_native_hdr)
+extern PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD;
+#endif /* defined(VK_AMD_display_native_hdr) */
+#if defined(VK_AMD_draw_indirect_count)
+extern PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD;
+extern PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD;
+#endif /* defined(VK_AMD_draw_indirect_count) */
+#if defined(VK_AMD_shader_info)
+extern PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD;
+#endif /* defined(VK_AMD_shader_info) */
+#if defined(VK_ANDROID_external_memory_android_hardware_buffer)
+extern PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID;
+extern PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID;
+#endif /* defined(VK_ANDROID_external_memory_android_hardware_buffer) */
+#if defined(VK_EXT_acquire_xlib_display)
+extern PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT;
+extern PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT;
+#endif /* defined(VK_EXT_acquire_xlib_display) */
+#if defined(VK_EXT_buffer_device_address)
+extern PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT;
+#endif /* defined(VK_EXT_buffer_device_address) */
+#if defined(VK_EXT_calibrated_timestamps)
+extern PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT;
+extern PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
+#endif /* defined(VK_EXT_calibrated_timestamps) */
+#if defined(VK_EXT_conditional_rendering)
+extern PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT;
+extern PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT;
+#endif /* defined(VK_EXT_conditional_rendering) */
+#if defined(VK_EXT_debug_marker)
+extern PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT;
+extern PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT;
+extern PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT;
+extern PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT;
+extern PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT;
+#endif /* defined(VK_EXT_debug_marker) */
+#if defined(VK_EXT_debug_report)
+extern PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT;
+extern PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT;
+extern PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
+#endif /* defined(VK_EXT_debug_report) */
+#if defined(VK_EXT_debug_utils)
+extern PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT;
+extern PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT;
+extern PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT;
+extern PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT;
+extern PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
+extern PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT;
+extern PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT;
+extern PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT;
+extern PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT;
+extern PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT;
+extern PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT;
+#endif /* defined(VK_EXT_debug_utils) */
+#if defined(VK_EXT_direct_mode_display)
+extern PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT;
+#endif /* defined(VK_EXT_direct_mode_display) */
+#if defined(VK_EXT_discard_rectangles)
+extern PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT;
+#endif /* defined(VK_EXT_discard_rectangles) */
+#if defined(VK_EXT_display_control)
+extern PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT;
+extern PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT;
+extern PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT;
+extern PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT;
+#endif /* defined(VK_EXT_display_control) */
+#if defined(VK_EXT_display_surface_counter)
+extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+#endif /* defined(VK_EXT_display_surface_counter) */
+#if defined(VK_EXT_external_memory_host)
+extern PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT;
+#endif /* defined(VK_EXT_external_memory_host) */
+#if defined(VK_EXT_full_screen_exclusive)
+extern PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT;
+extern PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT;
+extern PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT;
+#endif /* defined(VK_EXT_full_screen_exclusive) */
+#if defined(VK_EXT_hdr_metadata)
+extern PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT;
+#endif /* defined(VK_EXT_hdr_metadata) */
+#if defined(VK_EXT_headless_surface)
+extern PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT;
+#endif /* defined(VK_EXT_headless_surface) */
+#if defined(VK_EXT_host_query_reset)
+extern PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT;
+#endif /* defined(VK_EXT_host_query_reset) */
+#if defined(VK_EXT_image_drm_format_modifier)
+extern PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT;
+#endif /* defined(VK_EXT_image_drm_format_modifier) */
+#if defined(VK_EXT_line_rasterization)
+extern PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT;
+#endif /* defined(VK_EXT_line_rasterization) */
+#if defined(VK_EXT_metal_surface)
+extern PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT;
+#endif /* defined(VK_EXT_metal_surface) */
+#if defined(VK_EXT_sample_locations)
+extern PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT;
+extern PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT;
+#endif /* defined(VK_EXT_sample_locations) */
+#if defined(VK_EXT_tooling_info)
+extern PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT;
+#endif /* defined(VK_EXT_tooling_info) */
+#if defined(VK_EXT_transform_feedback)
+extern PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT;
+extern PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT;
+extern PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT;
+extern PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT;
+extern PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT;
+extern PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT;
+#endif /* defined(VK_EXT_transform_feedback) */
+#if defined(VK_EXT_validation_cache)
+extern PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT;
+extern PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT;
+extern PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT;
+extern PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT;
+#endif /* defined(VK_EXT_validation_cache) */
+#if defined(VK_FUCHSIA_imagepipe_surface)
+extern PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA;
+#endif /* defined(VK_FUCHSIA_imagepipe_surface) */
+#if defined(VK_GGP_stream_descriptor_surface)
+extern PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP;
+#endif /* defined(VK_GGP_stream_descriptor_surface) */
+#if defined(VK_GOOGLE_display_timing)
+extern PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE;
+extern PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE;
+#endif /* defined(VK_GOOGLE_display_timing) */
+#if defined(VK_INTEL_performance_query)
+extern PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL;
+extern PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL;
+extern PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL;
+extern PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL;
+extern PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL;
+extern PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL;
+extern PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL;
+extern PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL;
+extern PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL;
+#endif /* defined(VK_INTEL_performance_query) */
+#if defined(VK_KHR_android_surface)
+extern PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR;
+#endif /* defined(VK_KHR_android_surface) */
+#if defined(VK_KHR_bind_memory2)
+extern PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR;
+extern PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR;
+#endif /* defined(VK_KHR_bind_memory2) */
+#if defined(VK_KHR_buffer_device_address)
+extern PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR;
+extern PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR;
+extern PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR;
+#endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_create_renderpass2)
+extern PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR;
+extern PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR;
+extern PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR;
+extern PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR;
+#endif /* defined(VK_KHR_create_renderpass2) */
+#if defined(VK_KHR_descriptor_update_template)
+extern PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR;
+extern PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR;
+extern PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR;
+#endif /* defined(VK_KHR_descriptor_update_template) */
+#if defined(VK_KHR_device_group)
+extern PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR;
+extern PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR;
+extern PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR;
+#endif /* defined(VK_KHR_device_group) */
+#if defined(VK_KHR_device_group_creation)
+extern PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR;
+#endif /* defined(VK_KHR_device_group_creation) */
+#if defined(VK_KHR_display)
+extern PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR;
+extern PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
+extern PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
+extern PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
+extern PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
+extern PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+extern PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
+#endif /* defined(VK_KHR_display) */
+#if defined(VK_KHR_display_swapchain)
+extern PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR;
+#endif /* defined(VK_KHR_display_swapchain) */
+#if defined(VK_KHR_draw_indirect_count)
+extern PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR;
+extern PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR;
+#endif /* defined(VK_KHR_draw_indirect_count) */
+#if defined(VK_KHR_external_fence_capabilities)
+extern PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR;
+#endif /* defined(VK_KHR_external_fence_capabilities) */
+#if defined(VK_KHR_external_fence_fd)
+extern PFN_vkGetFenceFdKHR vkGetFenceFdKHR;
+extern PFN_vkImportFenceFdKHR vkImportFenceFdKHR;
+#endif /* defined(VK_KHR_external_fence_fd) */
+#if defined(VK_KHR_external_fence_win32)
+extern PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR;
+extern PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR;
+#endif /* defined(VK_KHR_external_fence_win32) */
+#if defined(VK_KHR_external_memory_capabilities)
+extern PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_capabilities) */
+#if defined(VK_KHR_external_memory_fd)
+extern PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR;
+extern PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_fd) */
+#if defined(VK_KHR_external_memory_win32)
+extern PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR;
+extern PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR;
+#endif /* defined(VK_KHR_external_memory_win32) */
+#if defined(VK_KHR_external_semaphore_capabilities)
+extern PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+#endif /* defined(VK_KHR_external_semaphore_capabilities) */
+#if defined(VK_KHR_external_semaphore_fd)
+extern PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR;
+extern PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR;
+#endif /* defined(VK_KHR_external_semaphore_fd) */
+#if defined(VK_KHR_external_semaphore_win32)
+extern PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR;
+extern PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR;
+#endif /* defined(VK_KHR_external_semaphore_win32) */
+#if defined(VK_KHR_get_display_properties2)
+extern PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR;
+extern PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR;
+extern PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+extern PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR;
+#endif /* defined(VK_KHR_get_display_properties2) */
+#if defined(VK_KHR_get_memory_requirements2)
+extern PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
+extern PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
+extern PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR;
+#endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_get_physical_device_properties2)
+extern PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR;
+extern PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR;
+extern PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR;
+extern PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR;
+extern PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR;
+extern PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+#endif /* defined(VK_KHR_get_physical_device_properties2) */
+#if defined(VK_KHR_get_surface_capabilities2)
+extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+extern PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
+#endif /* defined(VK_KHR_get_surface_capabilities2) */
+#if defined(VK_KHR_maintenance1)
+extern PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
+#endif /* defined(VK_KHR_maintenance1) */
+#if defined(VK_KHR_maintenance3)
+extern PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR;
+#endif /* defined(VK_KHR_maintenance3) */
+#if defined(VK_KHR_performance_query)
+extern PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR;
+extern PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
+extern PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
+extern PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR;
+#endif /* defined(VK_KHR_performance_query) */
+#if defined(VK_KHR_pipeline_executable_properties)
+extern PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR;
+extern PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR;
+extern PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR;
+#endif /* defined(VK_KHR_pipeline_executable_properties) */
+#if defined(VK_KHR_push_descriptor)
+extern PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR;
+#endif /* defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_sampler_ycbcr_conversion)
+extern PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR;
+extern PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR;
+#endif /* defined(VK_KHR_sampler_ycbcr_conversion) */
+#if defined(VK_KHR_shared_presentable_image)
+extern PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR;
+#endif /* defined(VK_KHR_shared_presentable_image) */
+#if defined(VK_KHR_surface)
+extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
+extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
+extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
+extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
+#endif /* defined(VK_KHR_surface) */
+#if defined(VK_KHR_swapchain)
+extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
+extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
+extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
+extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
+extern PFN_vkQueuePresentKHR vkQueuePresentKHR;
+#endif /* defined(VK_KHR_swapchain) */
+#if defined(VK_KHR_timeline_semaphore)
+extern PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR;
+extern PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR;
+extern PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR;
+#endif /* defined(VK_KHR_timeline_semaphore) */
+#if defined(VK_KHR_wayland_surface)
+extern PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR;
+extern PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+#endif /* defined(VK_KHR_wayland_surface) */
+#if defined(VK_KHR_win32_surface)
+extern PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR;
+extern PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR;
+#endif /* defined(VK_KHR_win32_surface) */
+#if defined(VK_KHR_xcb_surface)
+extern PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
+extern PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR;
+#endif /* defined(VK_KHR_xcb_surface) */
+#if defined(VK_KHR_xlib_surface)
+extern PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
+extern PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR;
+#endif /* defined(VK_KHR_xlib_surface) */
+#if defined(VK_MVK_ios_surface)
+extern PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK;
+#endif /* defined(VK_MVK_ios_surface) */
+#if defined(VK_MVK_macos_surface)
+extern PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK;
+#endif /* defined(VK_MVK_macos_surface) */
+#if defined(VK_NN_vi_surface)
+extern PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN;
+#endif /* defined(VK_NN_vi_surface) */
+#if defined(VK_NVX_device_generated_commands)
+extern PFN_vkCmdProcessCommandsNVX vkCmdProcessCommandsNVX;
+extern PFN_vkCmdReserveSpaceForCommandsNVX vkCmdReserveSpaceForCommandsNVX;
+extern PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX;
+extern PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX;
+extern PFN_vkDestroyIndirectCommandsLayoutNVX vkDestroyIndirectCommandsLayoutNVX;
+extern PFN_vkDestroyObjectTableNVX vkDestroyObjectTableNVX;
+extern PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+extern PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX;
+extern PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX;
+#endif /* defined(VK_NVX_device_generated_commands) */
+#if defined(VK_NVX_image_view_handle)
+extern PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX;
+#endif /* defined(VK_NVX_image_view_handle) */
+#if defined(VK_NV_clip_space_w_scaling)
+extern PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV;
+#endif /* defined(VK_NV_clip_space_w_scaling) */
+#if defined(VK_NV_cooperative_matrix)
+extern PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV;
+#endif /* defined(VK_NV_cooperative_matrix) */
+#if defined(VK_NV_coverage_reduction_mode)
+extern PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
+#endif /* defined(VK_NV_coverage_reduction_mode) */
+#if defined(VK_NV_device_diagnostic_checkpoints)
+extern PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV;
+extern PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV;
+#endif /* defined(VK_NV_device_diagnostic_checkpoints) */
+#if defined(VK_NV_external_memory_capabilities)
+extern PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+#endif /* defined(VK_NV_external_memory_capabilities) */
+#if defined(VK_NV_external_memory_win32)
+extern PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV;
+#endif /* defined(VK_NV_external_memory_win32) */
+#if defined(VK_NV_mesh_shader)
+extern PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV;
+extern PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV;
+extern PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV;
+#endif /* defined(VK_NV_mesh_shader) */
+#if defined(VK_NV_ray_tracing)
+extern PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV;
+extern PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV;
+extern PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV;
+extern PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV;
+extern PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV;
+extern PFN_vkCompileDeferredNV vkCompileDeferredNV;
+extern PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV;
+extern PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV;
+extern PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV;
+extern PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV;
+extern PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV;
+extern PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV;
+#endif /* defined(VK_NV_ray_tracing) */
+#if defined(VK_NV_scissor_exclusive)
+extern PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV;
+#endif /* defined(VK_NV_scissor_exclusive) */
+#if defined(VK_NV_shading_rate_image)
+extern PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV;
+extern PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV;
+extern PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV;
+#endif /* defined(VK_NV_shading_rate_image) */
+#if (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1))
+extern PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT;
+#endif /* (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1))
+extern PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR;
+#endif /* (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+extern PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR;
+extern PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR;
+extern PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR;
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_surface)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+#if (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1))
+extern PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR;
+#endif /* (defined(VK_KHR_device_group) && defined(VK_KHR_swapchain)) || (defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1)) */
+/* VOLK_GENERATE_PROTOTYPES_H */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef VOLK_IMPLEMENTATION
+#undef VOLK_IMPLEMENTATION
+// Prevent tools like dependency checkers that don't evaluate
+// macros from detecting a cyclic dependency.
+#define VOLK_SOURCE "volk.c"
+#include VOLK_SOURCE
+#endif
+
+/**
+ * Copyright (c) 2018-2019 Arseny Kapoulkine
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+*/
+/* clang-format on */