commit 46337bdeec4848c3807fa79aaa7567ec0fbb0a82 Author: l-proger Date: Tue May 13 02:24:09 2025 +0300 * diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..117f8d4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +/.vs +/Test/VulkanWrapperSandbox/build +/Test/VulkanWrapperSandbox/x64 +/build +/out diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..2d75b62 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,20 @@ +[submodule "Dependencies/LMath"] + path = Dependencies/LMath + url = https://github.com/L-proger/LMath.git + branch = master +[submodule "Dependencies/LFramework"] + path = Dependencies/LFramework + url = https://github.com/L-proger/LFramework.git + branch = main +[submodule "Dependencies/glslang"] + path = Dependencies/glslang + url = https://github.com/KhronosGroup/glslang.git + branch = main +[submodule "Dependencies/SPIRV-Tools"] + path = Dependencies/SPIRV-Tools + url = https://github.com/KhronosGroup/SPIRV-Tools.git + branch = main +[submodule "Dependencies/SPIRV-Headers"] + path = Dependencies/SPIRV-Headers + url = https://github.com/KhronosGroup/SPIRV-Headers.git + branch = main diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..f801b4b --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,17 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "(msvc) Launch", + "type": "cppvsdbg", + "request": "launch", + // Resolved by CMake Tools: + "program": "${command:cmake.launchTargetPath}", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + + "console": "externalTerminal" + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..3d19400 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,91 @@ +{ + "files.associations": { + "chrono": "cpp", + "system_error": "cpp", + "xlocale": "cpp", + "xtr1common": "cpp", + "iostream": "cpp", + "algorithm": "cpp", + "array": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "charconv": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "concepts": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "exception": "cpp", + "expected": "cpp", + "filesystem": "cpp", + "format": "cpp", + "forward_list": "cpp", + "fstream": "cpp", + "functional": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "istream": "cpp", + "iterator": "cpp", + "limits": "cpp", + "list": "cpp", + "locale": "cpp", + "map": "cpp", + "memory": "cpp", + "new": "cpp", + "optional": "cpp", + "ostream": "cpp", + "ratio": "cpp", + "set": "cpp", + "span": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "stop_token": "cpp", + "streambuf": "cpp", + "string": "cpp", + "thread": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeinfo": "cpp", + "unordered_map": "cpp", + "utility": "cpp", + "vector": "cpp", + "xfacet": "cpp", + "xhash": "cpp", + "xiosbase": "cpp", + "xlocbuf": "cpp", + "xlocinfo": "cpp", + "xlocmes": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xstring": "cpp", + "xtree": "cpp", + "xutility": "cpp", + "condition_variable": "cpp", + "deque": "cpp", + "future": "cpp", + "mutex": "cpp", + "ranges": "cpp", + "stack": "cpp", + "unordered_set": "cpp", + "bitset": "cpp", + "cinttypes": "cpp", + "cstdarg": "cpp", + "numeric": "cpp", + "queue": "cpp", + "random": "cpp", + "regex": "cpp", + "variant": "cpp" + } +} \ No newline at end of file diff --git a/CMake/VulkanTools.cmake b/CMake/VulkanTools.cmake new file mode 100644 index 0000000..d876b4d --- /dev/null +++ b/CMake/VulkanTools.cmake @@ -0,0 +1,180 @@ +macro(Vulkan_isDeviceFunction outVar funcName funcParams) + string(FIND "${funcParams}" "VkDevice" out1) + if(("${out1}" EQUAL 0) AND NOT("${funcName}" STREQUAL "PFN_vkGetDeviceProcAddr")) + set(${outVar} 1) + else() + set(${outVar} 0) + endif() +endmacro() + +macro(Vulkan_isDeviceCmdFunction outVar funcName funcParams) + string(FIND "${funcParams}" "VkCommandBuffer" out1) + if("${out1}" EQUAL 0) + set(${outVar} 1) + else() + set(${outVar} 0) + endif() +endmacro() + +macro(Vulkan_isDeviceQueueFunction outVar funcName funcParams) + string(FIND "${funcParams}" "VkQueue" out1) + if("${out1}" EQUAL 0) + set(${outVar} 1) + else() + set(${outVar} 0) + endif() +endmacro() + +macro(Vulkan_isInstanceFunction outVar funcName funcParams) + string(FIND "${funcParams}" "VkInstance" out1) + string(FIND "${funcParams}" "VkPhysicalDevice" out2) + if(("${out1}" EQUAL 0) OR ("${out2}" EQUAL 0) OR ("${funcName}" STREQUAL "PFN_vkGetDeviceProcAddr")) + set(${outVar} 1) + else() + set(${outVar} 0) + endif() +endmacro() + +macro(Vulkan_isGlobalFunction outVar funcName funcParams) + if(NOT(${funcName} MATCHES ".*MyFolderName$") AND NOT(${funcName} MATCHES ".*Function$") AND NOT(${funcName} MATCHES ".*Notification$")) + set(${outVar} 1) + else() + set(${outVar} 0) + endif() +endmacro() + + + + +set(Vulkan_paramNameRegex "([^* ]+)[ ]*$") +set(Vulkan_paramSplitFirstRestRegex "([ ]*[^,]+)[ ]*\,*[ ]*(.*)") + +macro(Vulkan_functionsFile_function className funcResultType funcName funcParams contextVarName) + string(REPLACE "PFN_" "" cleanFuncName ${funcName}) + + string(APPEND ${className}Loaders " _${cleanFuncName} = reinterpret_cast<${funcName}>(loader(\"${cleanFuncName}\"))\;\n" ) + + set(callArgs "") + if (NOT("${contextVarName}" STREQUAL "")) + string(REGEX MATCH "${Vulkan_paramSplitFirstRestRegex}" matchResultVar "${funcParams}") + set(InputCallParams "${CMAKE_MATCH_2}") + list(APPEND callArgs "_${contextVarName}") + else() + set(InputCallParams "${funcParams}") + endif() + + string(APPEND ${className}Pointers " ${funcName} _${cleanFuncName}\;\n") + + string(REPLACE "," ";" SplittedParams "${InputCallParams}") + foreach(param ${SplittedParams}) + string(REGEX MATCH "${Vulkan_paramNameRegex}" matchResultVar "${param}") + set(ParamName ${CMAKE_MATCH_1}) + + #Clean param name + string(REGEX MATCH "[ ]*([^ \[]+)" matchResultVar "${ParamName}") + #[ ]*([^ ]+)[ ]*\[.\]*[ ]*$ + list(APPEND callArgs ${CMAKE_MATCH_1}) + endforeach() + + list(JOIN callArgs ", " callArgsStr) + + if("${funcResultType}" STREQUAL "void") + set(returnString "") + else() + set(returnString "return ") + endif() + string(APPEND ${className}Functions " ${funcResultType} ${cleanFuncName}(${InputCallParams}) const {\n") + string(APPEND ${className}Functions " ${returnString}_${cleanFuncName}(${callArgsStr})\;\n") + string(APPEND ${className}Functions " }\n") +endmacro() + +macro(Vulkan_functionsFile_make className contextVarName contextVarType outFilePath ) + #File begin + set(${className}Result "") + string(APPEND ${className}Result "#pragma once\n") + string(APPEND ${className}Result "#include \n") + string(APPEND ${className}Result "#include \n") + #string(APPEND ${className}Result "#include \"VulkanInstance.h\"\n") + string(APPEND ${className}Result "class ${className} { \n") + + #File constructor + string(APPEND ${className}Result "public:\n") + if (NOT("${contextVarType}" STREQUAL "")) + set(ctroArgSuffix ", ${contextVarType} ${contextVarName}") + set(CtorInit " : _${contextVarName}(${contextVarName})") + else() + set(ctroArgSuffix "") + set(CtorInit "") + endif() + string(APPEND ${className}Result " ${className}(std::function loader${ctroArgSuffix})${CtorInit}{\n") + string(APPEND ${className}Result "${${className}Loaders}\n") + string(APPEND ${className}Result " }\n") + string(APPEND ${className}Result " ${className}(){}\n") + + + #Public functions + string(APPEND ${className}Result "${${className}Functions}\n") + #Private fields + string(APPEND ${className}Result "private:\n") + string(APPEND ${className}Result "${${className}Pointers}\n") + + #Context object + if (NOT("${contextVarType}" STREQUAL "")) + string(APPEND ${className}Result " ${contextVarType} _${contextVarName} = {}\;\n") + endif() + + #File end + string(APPEND ${className}Result "}\;\n") #End class + + #File save + file(WRITE "${outFilePath}" ${${className}Result}) +endmacro() + +function(Vulkan_generateFunctionsFile outFileDir) + set(VULKAN_CORE_H "${Vulkan_INCLUDE_DIR}/vulkan/vulkan_core.h") + file(STRINGS "${VULKAN_CORE_H}" VULKAN_CORE_H_STRINGS) + + + foreach(STR ${VULKAN_CORE_H_STRINGS}) + string(REGEX MATCH ".*typedef[ ]+([^ ]+)[ ]+\\([ ]*VKAPI_PTR[ ]+\\*([^\\)]+)\\)[ ]*\\(([^\\)]+)\\)" matchResultVar "${STR}") + if(NOT("${CMAKE_MATCH_2}" STREQUAL "")) + set(FN_RESULT "${CMAKE_MATCH_1}") + set(FN_NAME "${CMAKE_MATCH_2}") + set(FN_PARAMS "${CMAKE_MATCH_3}") + + Vulkan_isDeviceFunction("found" "${FN_NAME}" "${FN_PARAMS}") + if("${found}" EQUAL 1) + Vulkan_functionsFile_function(VulkanDeviceFunctions "${FN_RESULT}" "${FN_NAME}" "${FN_PARAMS}" "device") + endif() + + Vulkan_isDeviceCmdFunction("found" "${FN_NAME}" "${FN_PARAMS}") + if("${found}" EQUAL 1) + Vulkan_functionsFile_function(VulkanDeviceFunctions "${FN_RESULT}" "${FN_NAME}" "${FN_PARAMS}" "") + endif() + + Vulkan_isDeviceQueueFunction("found" "${FN_NAME}" "${FN_PARAMS}") + if("${found}" EQUAL 1) + Vulkan_functionsFile_function(VulkanDeviceFunctions "${FN_RESULT}" "${FN_NAME}" "${FN_PARAMS}" "") + endif() + + + + Vulkan_isInstanceFunction("found" "${FN_NAME}" "${FN_PARAMS}") + if("${found}" EQUAL 1) + Vulkan_functionsFile_function(VulkanInstanceFunctions "${FN_RESULT}" "${FN_NAME}" "${FN_PARAMS}" "") + endif() + + Vulkan_isGlobalFunction("found" "${FN_NAME}" "${FN_PARAMS}") + if("${found}" EQUAL 1) + Vulkan_functionsFile_function(VulkanGlobalFunctions "${FN_RESULT}" "${FN_NAME}" "${FN_PARAMS}" "") + endif() + endif() + endforeach() + + + + Vulkan_functionsFile_make(VulkanDeviceFunctions "device" "VkDevice" "${outFileDir}/VulkanDeviceFunctions.h") + Vulkan_functionsFile_make(VulkanInstanceFunctions "" "" "${outFileDir}/VulkanInstanceFunctions.h") + Vulkan_functionsFile_make(VulkanGlobalFunctions "" "" "${outFileDir}/VulkanGlobalFunctions.h") + +endfunction() diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..719a9f0 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,39 @@ +cmake_minimum_required(VERSION 3.24) + +list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake") + +project(RenderFramework C CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_C_STANDARD 11) + +if(MSVC_VERSION GREATER 1500) + include(ProcessorCount) + ProcessorCount(N) + if(NOT N EQUAL 0) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP${N}" CACHE STRING "" FORCE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP${N}" CACHE STRING "" FORCE) + set(CMAKE_CSharp_FLAGS "${CMAKE_CSharp_FLAGS} /m:${N}" CACHE STRING "" FORCE) + endif() +endif() + +add_subdirectory(Dependencies/LFramework) +add_subdirectory(Dependencies/LMath) + + +set(ENABLE_GLSLANG_BINARIES OFF) +set(ALLOW_EXTERNAL_SPIRV_TOOLS ON) +set(ENABLE_EXCEPTIONS ON) +find_package(Vulkan REQUIRED) + +set(SPIRV_TOOLS_BUILD_STATIC ON) +set(SPIRV_SKIP_EXECUTABLES 1) + +add_subdirectory(Dependencies/SPIRV-Headers) +add_subdirectory(Dependencies/SPIRV-Tools) +# +add_subdirectory(Dependencies/glslang) + +add_subdirectory(Src) +add_subdirectory(Examples/GameEditor) + diff --git a/Dependencies/LFramework b/Dependencies/LFramework new file mode 160000 index 0000000..3f509a2 --- /dev/null +++ b/Dependencies/LFramework @@ -0,0 +1 @@ +Subproject commit 3f509a23c4ab9a3ab39549f3f63701019fbf8df6 diff --git a/Dependencies/LMath b/Dependencies/LMath new file mode 160000 index 0000000..4281853 --- /dev/null +++ b/Dependencies/LMath @@ -0,0 +1 @@ +Subproject commit 428185341bb819f99a16d7ea8d8290d8d126389e diff --git a/Dependencies/SPIRV-Headers b/Dependencies/SPIRV-Headers new file mode 160000 index 0000000..6d0784e --- /dev/null +++ b/Dependencies/SPIRV-Headers @@ -0,0 +1 @@ +Subproject commit 6d0784e9f1ab92c17eeea94821b2465c14a52be9 diff --git a/Dependencies/SPIRV-Tools b/Dependencies/SPIRV-Tools new file mode 160000 index 0000000..feba06f --- /dev/null +++ b/Dependencies/SPIRV-Tools @@ -0,0 +1 @@ +Subproject commit feba06f44f682e17e0efcd412dff8de74a23d63a diff --git a/Dependencies/glslang b/Dependencies/glslang new file mode 160000 index 0000000..9635880 --- /dev/null +++ b/Dependencies/glslang @@ -0,0 +1 @@ +Subproject commit 963588074b26326ff0426c8953c1235213309bdb diff --git a/Examples/Assets/Boxes.mtl b/Examples/Assets/Boxes.mtl new file mode 100644 index 0000000..7665742 --- /dev/null +++ b/Examples/Assets/Boxes.mtl @@ -0,0 +1,26 @@ +# 3ds Max Wavefront OBJ Exporter v0.97b - (c)2007 guruware +# File Created: 22.09.2015 22:34:25 + +newmtl RedCube + Ns 9.999999 + Ni 1.500000 + d 1.000000 + Tr 0.000000 + Tf 1.000000 1.000000 1.000000 + illum 2 + Ka 1.000000 0.000000 0.000000 + Kd 1.000000 0.000000 0.000000 + Ks 0.000000 0.000000 0.000000 + Ke 0.000000 0.000000 0.000000 + +newmtl BlueCube + Ns 9.999999 + Ni 1.500000 + d 1.000000 + Tr 0.000000 + Tf 1.000000 1.000000 1.000000 + illum 2 + Ka 0.047059 0.000000 1.000000 + Kd 0.047059 0.000000 1.000000 + Ks 0.000000 0.000000 0.000000 + Ke 0.000000 0.000000 0.000000 diff --git a/Examples/Assets/Boxes.obj b/Examples/Assets/Boxes.obj new file mode 100644 index 0000000..4b17746 --- /dev/null +++ b/Examples/Assets/Boxes.obj @@ -0,0 +1,105 @@ +# 3dA Max Wavefront OBJ Exporter v0.97b - (c)2007 guruware +# File Created: 22.09.2015 22:34:25 + +mtllib Boxes.mtl + +# +# object RedBox +# + +v -0.500000 0.000000 0.500000 +v -0.500000 0.000000 -0.500000 +v 0.500000 0.000000 -0.500000 +v 0.500000 0.000000 0.500000 +v -0.500000 1.000000 0.500000 +v 0.500000 1.000000 0.500000 +v 0.500000 1.000000 -0.500000 +v -0.500000 1.000000 -0.500000 +# 8 vertices + +vn 0.000000 -1.000000 -0.000000 +vn 0.000000 1.000000 -0.000000 +vn 0.000000 0.000000 1.000000 +vn 1.000000 0.000000 -0.000000 +vn 0.000000 0.000000 -1.000000 +vn -1.000000 0.000000 -0.000000 +# 6 vertex normals + +vt 1.000000 0.000000 0.000000 +vt 1.000000 1.000000 0.000000 +vt 0.000000 1.000000 0.000000 +vt 0.000000 0.000000 0.000000 +# 4 texture coords + +g RedBox +usemtl RedCube +s 2 +f 1/1/1 2/2/1 3/3/1 +f 3/3/1 4/4/1 1/1/1 +s 4 +f 5/4/2 6/1/2 7/2/2 +f 7/2/2 8/3/2 5/4/2 +s 8 +f 1/4/3 4/1/3 6/2/3 +f 6/2/3 5/3/3 1/4/3 +s 16 +f 4/4/4 3/1/4 7/2/4 +f 7/2/4 6/3/4 4/4/4 +s 32 +f 3/4/5 2/1/5 8/2/5 +f 8/2/5 7/3/5 3/4/5 +s 64 +f 2/4/6 1/1/6 5/2/6 +f 5/2/6 8/3/6 2/4/6 +# 12 faces + +# +# object BlueBox +# + +v -0.500000 0.000000 1.978305 +v -0.500000 0.000000 0.978305 +v 0.500000 0.000000 0.978305 +v 0.500000 0.000000 1.978305 +v -0.500000 1.000000 1.978305 +v 0.500000 1.000000 1.978305 +v 0.500000 1.000000 0.978305 +v -0.500000 1.000000 0.978305 +# 8 vertices + +vn 0.000000 -1.000000 -0.000000 +vn 0.000000 1.000000 -0.000000 +vn 0.000000 0.000000 1.000000 +vn 1.000000 0.000000 -0.000000 +vn 0.000000 0.000000 -1.000000 +vn -1.000000 0.000000 -0.000000 +# 6 vertex normals + +vt 1.000000 0.000000 0.000000 +vt 1.000000 1.000000 0.000000 +vt 0.000000 1.000000 0.000000 +vt 0.000000 0.000000 0.000000 +# 4 texture coords + +g BlueBox +usemtl BlueCube +s 2 +f 9/5/7 10/6/7 11/7/7 +f 11/7/7 12/8/7 9/5/7 +s 4 +f 13/8/8 14/5/8 15/6/8 +f 15/6/8 16/7/8 13/8/8 +s 8 +f 9/8/9 12/5/9 14/6/9 +f 14/6/9 13/7/9 9/8/9 +s 16 +f 12/8/10 11/5/10 15/6/10 +f 15/6/10 14/7/10 12/8/10 +s 32 +f 11/8/11 10/5/11 16/6/11 +f 16/6/11 15/7/11 11/8/11 +s 64 +f 10/8/12 9/5/12 13/6/12 +f 13/6/12 16/7/12 10/8/12 +# 12 faces + diff --git a/Examples/Assets/Boxes.obj.meta b/Examples/Assets/Boxes.obj.meta new file mode 100644 index 0000000..845c679 --- /dev/null +++ b/Examples/Assets/Boxes.obj.meta @@ -0,0 +1,3 @@ +1.0 +{6799A53E-CBB1-451A-82C7-E5F10C33EBCA} +14435573237290376 diff --git a/Examples/Assets/Shaders/car_shader.fx b/Examples/Assets/Shaders/car_shader.fx new file mode 100644 index 0000000..98b6aa5 --- /dev/null +++ b/Examples/Assets/Shaders/car_shader.fx @@ -0,0 +1,57 @@ +struct VS_INPUT { + float4 vPosition : POSITION; + float3 normal : NORMAL; + float2 uv0 : UV0; + float2 uv1 : UV1; +}; + +struct VS_OUTPUT { + float4 vPosition : SV_POSITION; + float3 normal : TEXCOORD0; + float2 uv0 : TEXCOORD1; + float2 uv1 : TEXCOORD2; + float3 worldPos : TEXCOORD3; +}; + +cbuffer TestBuffer : register(b3) { + float4x4 mWorld; + float4x4 mView; + float4x4 mProjection; + float4 cameraWorldPos; +} + +Texture2D diffuse : register(t0); +Texture2D tex2 : register(t1); +SamplerState MeshTextureSampler; + + + +VS_OUTPUT main_vs(VS_INPUT v) { + VS_OUTPUT o; + + float4x4 wvp = mul(mul(mProjection, mView), mWorld); + + o.vPosition = mul(wvp, float4(v.vPosition.xyz, 1)); + + o.normal = mul((float3x3)mWorld, v.normal); + o.uv0 = v.uv0; + o.uv1 = v.uv1; + o.worldPos = mul((float3x3)mWorld, v.vPosition.xyz); + return o; +} + +#include "lighting/cook_torrance_term.inc" + +float4 main_ps(VS_OUTPUT input) : SV_Target +{ + float3 ambient = float3(0.3f, 0.3f, 0.4f); + + float4 diffuseColor = 1.0f;// diffuse.Sample(MeshTextureSampler, input.uv0); + float3 worldPos = input.worldPos; + float3 camPos = cameraWorldPos.xyz; + float3 viewDir = normalize(camPos - worldPos); + float3 sun = normalize(float3(-1, 1, -1)); + + float3 surfaceColor = cook_torrance(normalize(input.normal), viewDir, sun, 0.1f, 1.0f, float3(1,1,1), diffuseColor.rgb); + return float4(surfaceColor + ambient * diffuseColor, 1); +} \ No newline at end of file diff --git a/Examples/Assets/Shaders/default.fx b/Examples/Assets/Shaders/default.fx new file mode 100644 index 0000000..d9007ad --- /dev/null +++ b/Examples/Assets/Shaders/default.fx @@ -0,0 +1,64 @@ +struct VS_INPUT +{ + float4 vPosition : POSITION; + float3 normal : NORMAL; + float2 uv0 : UV0; + float2 uv1 : UV1; +}; + +struct VS_OUTPUT { + float4 vPosition : SV_POSITION; + float3 normal : TEXCOORD0; + float2 uv0 : TEXCOORD1; + float2 uv1 : TEXCOORD2; + float3 worldPos : TEXCOORD3; + float3 viewPos : TEXCOORD4; +}; + +cbuffer TestBuffer : register(b3) { + float4x4 mWorld; + float4x4 mView; + float4x4 mProjection; + float4 cameraWorldPos; + float4 _DiffuseColor; +} + +Texture2D diffuse : register(t0); +Texture2D tex2 : register(t1); +SamplerState MeshTextureSampler; + + + +VS_OUTPUT main_vs(VS_INPUT v){ + VS_OUTPUT o; + + + float4x4 wv = mul(mView, mWorld); + float4x4 wvp = mul(mul(mProjection, mView), mWorld); + + o.vPosition = mul(wvp, float4(v.vPosition.xyz,1)); + + o.normal = mul((float3x3)mWorld, v.normal); + o.uv0 = v.uv0; + o.uv1 = v.uv1; + o.worldPos = mul((float3x3)mWorld, v.vPosition.xyz); + o.viewPos = mul(wv, float4(v.vPosition.xyz, 1)); + return o; +} + +#include "lighting/cook_torrance_term.inc" + +float4 main_ps(VS_OUTPUT input) : SV_Target +{ + float3 ambient = float3(0.3f, 0.3f, 0.4f); + + float4 diffuseColor = _DiffuseColor * diffuse.Sample(MeshTextureSampler, input.uv0); + float3 worldPos = input.worldPos; + float3 camPos = cameraWorldPos.xyz; + float3 viewDir = normalize(camPos - worldPos); + float3 sun = normalize(float3(-1, 1, -1)); + + float3 surfaceColor = cook_torrance(normalize(input.normal), viewDir, sun, 0.7f, 0.1f, diffuseColor.rgb, diffuseColor.rgb); + + return float4(surfaceColor + ambient * diffuseColor, 1); +} \ No newline at end of file diff --git a/Examples/Assets/Shaders/gizmos.fx b/Examples/Assets/Shaders/gizmos.fx new file mode 100644 index 0000000..5c63d54 --- /dev/null +++ b/Examples/Assets/Shaders/gizmos.fx @@ -0,0 +1,32 @@ +struct VS_INPUT +{ + float4 position : POSITION; + float4 color : COLOR; +}; + +struct VS_OUTPUT { + float4 position : SV_POSITION; + float4 color : TEXCOORD0; +}; + +cbuffer TestBuffer : register(b3) { + float4x4 mWorld; + float4x4 mView; + float4x4 mProjection; + float alphaMul; +} + +VS_OUTPUT main_vs(VS_INPUT v) { + VS_OUTPUT o; + + float4x4 wvp = mul(mul(mProjection, mView), mWorld); + o.position = mul(wvp, float4(v.position.xyz, 1)); + o.color = v.color; + return o; +} + +float4 main_ps(VS_OUTPUT input) : SV_Target{ + float4 color = input.color; + color *= alphaMul; + return color; +} \ No newline at end of file diff --git a/Examples/Assets/Shaders/lighting/cook_torrance_term.inc b/Examples/Assets/Shaders/lighting/cook_torrance_term.inc new file mode 100644 index 0000000..460277d --- /dev/null +++ b/Examples/Assets/Shaders/lighting/cook_torrance_term.inc @@ -0,0 +1,70 @@ +#ifndef COOK_TORRANCE_TERM +#define COOK_TORRANCE_TERM + +float4 cook_torrance( + in float3 normal, + in float3 viewer, + in float3 light, float roughness_value, float ref_at_norm_incidence, float3 cSpecular, float3 cDiffuse) +{ + // Compute any aliases and intermediary values + // ------------------------------------------- + float3 half_vector = normalize( light + viewer ); + float NdotL = saturate( dot( normal, light ) ); + float NdotH = max( dot( normal, half_vector ) , 1.0e-7); + float NdotV = saturate( dot( normal, viewer ) ); + float VdotH = saturate( dot( viewer, half_vector ) ); + float r_sq = roughness_value * roughness_value; + + + + // Evaluate the geometric term + // -------------------------------- + float geo_numerator = 2.0f * NdotH; + float geo_denominator = VdotH; + + float geo_b = (geo_numerator * NdotV ) / geo_denominator; + float geo_c = (geo_numerator * NdotL ) / geo_denominator; + float geo = min( 1.0f, min( geo_b, geo_c ) ); + + + + // Now evaluate the roughness term + // ------------------------------- + float roughness; + float roughness_a = 1.0f / ( 4.0f * r_sq * pow( NdotH, 4 ) ); + float roughness_b = NdotH * NdotH - 1.0f; + float roughness_c = r_sq * NdotH * NdotH; + roughness = roughness_a * exp( roughness_b / roughness_c ); + + + // Next evaluate the Fresnel value + // ------------------------------- + float fresnel = pow( 1.0f - VdotH, 5.0f ); + fresnel *= ( 1.0f - ref_at_norm_incidence ); + fresnel += ref_at_norm_incidence; + + + + // Put all the terms together to compute + // the specular term in the equation + // ------------------------------------- + float3 Rs_numerator = ( fresnel * geo * roughness ); + float Rs_denominator = max(1.0e-7, NdotV * NdotL); + float3 Rs = Rs_numerator/ Rs_denominator; + + + + // Put all the parts together to generate + // the final colour + // -------------------------------------- + + + Rs = max(0, Rs); + float3 final = max(0.0f, NdotL) *cDiffuse + (1 * Rs ); + + // Return the result + // ----------------- + return float4( final, 1.0f ); +} + +#endif \ No newline at end of file diff --git a/Examples/Assets/Shaders/red_shader.fx b/Examples/Assets/Shaders/red_shader.fx new file mode 100644 index 0000000..d2ab3fb --- /dev/null +++ b/Examples/Assets/Shaders/red_shader.fx @@ -0,0 +1,47 @@ +struct VS_INPUT +{ + float4 vPosition : POSITION; + float3 normal : NORMAL; + float2 uv0 : UV0; + float2 uv1 : UV1; +}; + +struct VS_OUTPUT { + float4 vPosition : SV_POSITION; + float3 normal : TEXCOORD0; + float2 uv0 : TEXCOORD1; + float2 uv1 : TEXCOORD2; +}; + +cbuffer TestBuffer : register(b3) { + float4x4 mWorld; + float4x4 mView; + float4x4 mProjection; +} + +Texture2D tex : register(t0); +Texture2D tex2 : register(t1); +SamplerState MeshTextureSampler; + +VS_OUTPUT main_vs(VS_INPUT v) { + VS_OUTPUT o; + + float4x4 wvp = mul(mul(mProjection, mView), mWorld); + + o.vPosition = mul(wvp, float4(v.vPosition.xyz, 1)); + + o.normal = mul((float3x3)mWorld, v.normal); + o.uv0 = v.uv0; + o.uv1 = v.uv1; + return o; +} + + +float4 main_ps(VS_OUTPUT input) : SV_Target +{ + float3 sun = normalize(float3(-1,1,-1)); + float lit = dot(sun, input.normal); + float3 diffuse = float3(1, 0, 0); + + return float4(diffuse * lit, 1); +} \ No newline at end of file diff --git a/Examples/Assets/Shaders/shader.fx b/Examples/Assets/Shaders/shader.fx new file mode 100644 index 0000000..b09811c --- /dev/null +++ b/Examples/Assets/Shaders/shader.fx @@ -0,0 +1,63 @@ +struct VS_INPUT +{ + float4 vPosition : POSITION; + float3 normal : NORMAL; + float2 uv0 : UV0; + float2 uv1 : UV1; +}; + +struct VS_OUTPUT { + float4 vPosition : SV_POSITION; + float3 normal : TEXCOORD0; + float2 uv0 : TEXCOORD1; + float2 uv1 : TEXCOORD2; + float3 worldPos : TEXCOORD3; + float3 viewPos : TEXCOORD4; +}; + +cbuffer TestBuffer : register(b3) { + float4x4 mWorld; + float4x4 mView; + float4x4 mProjection; + float4 cameraWorldPos; +} + +Texture2D diffuse : register(t0); +SamplerState MeshTextureSampler : register(s0); + + + +VS_OUTPUT main_vs(VS_INPUT v){ + VS_OUTPUT o; + + + float4x4 wv = mul(mView, mWorld); + float4x4 wvp = mul(mul(mProjection, mView), mWorld); + + o.vPosition = mul(wvp, float4(v.vPosition.xyz,1)); + + o.normal = mul((float3x3)mWorld, v.normal); + o.uv0 = v.uv0; + o.uv1 = v.uv1; + o.worldPos = mul((float3x3)mWorld, v.vPosition.xyz); + o.viewPos = mul(wv, float4(v.vPosition.xyz, 1)); + return o; +} + +#include "lighting/cook_torrance_term.inc" + +float4 main_ps(VS_OUTPUT input) : SV_Target +{ + float3 ambient = float3(0.3f, 0.3f, 0.4f); + + float4 diffuseColor = diffuse.Sample(MeshTextureSampler, input.uv0); + return diffuseColor; + float3 worldPos = input.worldPos; + float3 camPos = cameraWorldPos.xyz; + float3 viewDir = normalize(camPos - worldPos); + float3 sun = normalize(float3(-1, 1, -1)); + + float3 surfaceColor = cook_torrance(normalize(input.normal), viewDir, sun, 0.7f, 0.1f, diffuseColor.rgb, diffuseColor.rgb); + + return float4(surfaceColor + ambient * diffuseColor, 1); +} \ No newline at end of file diff --git a/Examples/Assets/Shaders/vk.frag b/Examples/Assets/Shaders/vk.frag new file mode 100644 index 0000000..284e7ea --- /dev/null +++ b/Examples/Assets/Shaders/vk.frag @@ -0,0 +1,10 @@ + +#version 450 +#extension GL_ARB_separate_shader_objects : enable +layout(location = 0) in vec3 fragColor; + +layout(location = 0) out vec4 outColor; + +void main() { + outColor = vec4(fragColor, 1.0); +} \ No newline at end of file diff --git a/Examples/Assets/Shaders/vk.vert b/Examples/Assets/Shaders/vk.vert new file mode 100644 index 0000000..ab56534 --- /dev/null +++ b/Examples/Assets/Shaders/vk.vert @@ -0,0 +1,18 @@ + #version 450 + #extension GL_ARB_separate_shader_objects : enable + + layout(binding = 0) uniform UniformBufferObject { + mat4 model; + mat4 view; + mat4 proj; + } ubo; + + layout(location = 0) in vec3 inPosition; + layout(location = 2) in vec3 inColor; + + layout(location = 0) out vec3 fragColor; + + void main() { + gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition.xyz, 1.0); + fragColor = vec3(inColor.xyz); + } \ No newline at end of file diff --git a/Examples/Assets/Textures/1_store.dds b/Examples/Assets/Textures/1_store.dds new file mode 100644 index 0000000..93d630a Binary files /dev/null and b/Examples/Assets/Textures/1_store.dds differ diff --git a/Examples/GameEditor/BoundsView.h b/Examples/GameEditor/BoundsView.h new file mode 100644 index 0000000..c20c208 --- /dev/null +++ b/Examples/GameEditor/BoundsView.h @@ -0,0 +1,13 @@ +#ifndef BoundsView_h__ +#define BoundsView_h__ + +#include + +LOBJECT(BoundsView, Component) +public: + void tick(float deltaTime) override { + LEngine::Instance()->GetActiveScene()->GetGizmos().SetMatrix(transform()->GetGlobalTransform()); + LEngine::Instance()->GetActiveScene()->GetGizmos().DrawBounds(gameObject->GetComponent()->GetMesh()->GetBounds()); + } +}; +#endif // BoundsView_h__ diff --git a/Examples/GameEditor/CMakeLists.txt b/Examples/GameEditor/CMakeLists.txt new file mode 100644 index 0000000..351fea7 --- /dev/null +++ b/Examples/GameEditor/CMakeLists.txt @@ -0,0 +1,29 @@ +cmake_minimum_required(VERSION 3.16) + +add_executable(GameEditor) + +target_sources(GameEditor +PRIVATE + BoundsView.h + FreeCameraController.h + GameEditor.cpp + GameEditor.h + LFrameworkConfig.h +) + +#target_include_directories(GameEditor +#PRIVATE +# +#) + +target_link_libraries(GameEditor +PRIVATE + RenderFramework + LFramework + LFramework::Input +) + +target_compile_definitions(GameEditor +PRIVATE + ASSETS_DIR=L"${CMAKE_CURRENT_LIST_DIR}/../Assets" +) \ No newline at end of file diff --git a/Examples/GameEditor/FreeCameraController.h b/Examples/GameEditor/FreeCameraController.h new file mode 100644 index 0000000..0592cba --- /dev/null +++ b/Examples/GameEditor/FreeCameraController.h @@ -0,0 +1,65 @@ +#pragma once + +#include +#include "lframework/Input/Input.h" +#include +#include +#include + +LOBJECT(FreeCameraController, Component) +public: + float mouse_speed; + float move_speed = 3.0f; + static constexpr float pi = 3.14159265358979f; + + FreeCameraController() : mouse_speed(0.01f){ + _angle_x = _angle_y = 0.0f; + } + + virtual void tick(float deltaTime) override { + auto mice = Input::Instance()->mice(); + auto mouse = mice[0]; + _angle_x += mouse_speed * mouse->GetDx(); + _angle_y += mouse_speed * mouse->GetDy(); + + _angle_y = clamp(_angle_y, -pi / 2.0f, pi / 2.0f); + + auto rv = Quaternion_f::angleAxis(_angle_y, float3(1.0f, 0.0f, 0.0f)); + auto rh = Quaternion_f::angleAxis(_angle_x, float3(0.0f, 1.0f, 0.0f)); + + /* if (mouse->GetDx() != 0) { + std::cout << "Mouse DX: " << mouse->GetDx() << std::endl; + } + if (mouse->GetDy() != 0) { + std::cout << "Mouse DY: " << mouse->GetDy() << std::endl; + }*/ + + gameObject->transform->SetLocalRotation(lm::mul(rh, rv)); + + + + auto keyboards = Input::Instance()->keyboards(); + auto keyboard = keyboards[0]; + + if(keyboard->GetKeyState(0x57)){ + gameObject->transform->SetLocalPosition(gameObject->transform->GetLocalPosition() + gameObject->transform->forward() * (deltaTime * move_speed)); + } + + if (keyboard->GetKeyState(0x53)) { + gameObject->transform->SetLocalPosition(gameObject->transform->GetLocalPosition() - gameObject->transform->forward() * (deltaTime * move_speed)); + } + + if (keyboard->GetKeyState(0x41)) { + gameObject->transform->SetLocalPosition(gameObject->transform->GetLocalPosition() - gameObject->transform->right() * (deltaTime * move_speed)); + } + + if (keyboard->GetKeyState(0x44)) { + gameObject->transform->SetLocalPosition(gameObject->transform->GetLocalPosition() + gameObject->transform->right() * (deltaTime * move_speed)); + } + + + } +private: + float _angle_x; + float _angle_y; +}; diff --git a/Examples/GameEditor/GameEditor.cpp b/Examples/GameEditor/GameEditor.cpp new file mode 100644 index 0000000..bd67027 Binary files /dev/null and b/Examples/GameEditor/GameEditor.cpp differ diff --git a/Examples/GameEditor/GameEditor.h b/Examples/GameEditor/GameEditor.h new file mode 100644 index 0000000..6f70f09 --- /dev/null +++ b/Examples/GameEditor/GameEditor.h @@ -0,0 +1 @@ +#pragma once diff --git a/Examples/GameEditor/LFrameworkConfig.h b/Examples/GameEditor/LFrameworkConfig.h new file mode 100644 index 0000000..a1294f0 --- /dev/null +++ b/Examples/GameEditor/LFrameworkConfig.h @@ -0,0 +1,4 @@ +#pragma once + + +#define LF_INPUT \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..c601e39 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# RenderFramework \ No newline at end of file diff --git a/Src/CMakeLists.txt b/Src/CMakeLists.txt new file mode 100644 index 0000000..ca0e720 --- /dev/null +++ b/Src/CMakeLists.txt @@ -0,0 +1,86 @@ + +add_subdirectory(RenderFramework/Vulkan) + +add_library(RenderFramework STATIC) + +target_sources(RenderFramework +PRIVATE + RenderFramework/Archive.cpp + RenderFramework/Archive.h + RenderFramework/Asset.h + RenderFramework/AssetDatabase.cpp + RenderFramework/AssetDatabase.h + RenderFramework/AssetFile.h + RenderFramework/AssetImporter.h + RenderFramework/AssetManager.cpp + RenderFramework/AssetManager.h + RenderFramework/AssetMetadata.cpp + RenderFramework/AssetMetadata.h + RenderFramework/Bounds.h + RenderFramework/Camera.cpp + RenderFramework/Camera.h + RenderFramework/Component.cpp + RenderFramework/Component.h + RenderFramework/FatalError.h + RenderFramework/File.h + RenderFramework/Filesystem.h + RenderFramework/ForwardDeclarations.h + RenderFramework/ForwardListItem.h + RenderFramework/GameObject.cpp + RenderFramework/GameObject.h + RenderFramework/Gizmos.cpp + RenderFramework/Gizmos.h + RenderFramework/GizmoVertex.h + RenderFramework/Guid.h + RenderFramework/InputArchive.h + RenderFramework/LEngine.cpp + RenderFramework/LEngine.h + RenderFramework/Material.cpp + RenderFramework/Material.h + RenderFramework/Mathf.h + RenderFramework/Mesh.cpp + RenderFramework/Mesh.h + RenderFramework/MeshGenerator.cpp + RenderFramework/MeshGenerator.h + RenderFramework/MeshRenderer.cpp + RenderFramework/MeshRenderer.h + RenderFramework/ModelImporter.h + RenderFramework/Object.cpp + RenderFramework/Object.h + RenderFramework/ObjectsFactory.cpp + RenderFramework/ObjectsFactory.h + RenderFramework/ObjMeshLoader.h + RenderFramework/OutputArchive.h + RenderFramework/Renderer.cpp + RenderFramework/Renderer.h + RenderFramework/RenderOutput.h + RenderFramework/RenderTargetOutput.cpp + RenderFramework/RenderTargetOutput.h + RenderFramework/Scene.cpp + RenderFramework/Scene.h + RenderFramework/SceneRenderer.cpp + RenderFramework/SceneRenderer.h + RenderFramework/Shader.cpp + RenderFramework/Shader.h + RenderFramework/ShaderInclude.h + RenderFramework/ShaderParametersBlock.h + RenderFramework/Submesh.h + RenderFramework/SwapChainOutput.h + RenderFramework/Texture.h + RenderFramework/TextureImporter.h + RenderFramework/Transform.h + RenderFramework/Vertex.h + RenderFramework/WindowRenderOutput.cpp + RenderFramework/WindowRenderOutput.h +) + +target_link_libraries(RenderFramework +PUBLIC + VulkanWrapper + LMath +) + +target_include_directories(RenderFramework +PUBLIC + ./ +) \ No newline at end of file diff --git a/Src/RenderFramework/Archive.cpp b/Src/RenderFramework/Archive.cpp new file mode 100644 index 0000000..c6eee2d --- /dev/null +++ b/Src/RenderFramework/Archive.cpp @@ -0,0 +1,7 @@ +#include "Archive.h" + + + +Archive& Archive::operator << (AssetFileLink& value) { + serialize(&value, sizeof(value)); return *this; +} \ No newline at end of file diff --git a/Src/RenderFramework/Archive.h b/Src/RenderFramework/Archive.h new file mode 100644 index 0000000..6301a12 --- /dev/null +++ b/Src/RenderFramework/Archive.h @@ -0,0 +1,109 @@ +#ifndef Archive_h__ +#define Archive_h__ + + +#include +#include +#include +#include +#include "Asset.h" +#include +#include +#include "Object.h" +#include +#define POD_SERIALIZE(_type) Archive& operator << (_type& value) { serialize(&value, sizeof(value)); return *this; } + +class Object; +class Archive { +public: + typedef uint64_t size_type; + std::function)> SaveReferenceCallback; + std::function(const AssetFileLink&)> LoadReferenceCallback; + + Archive():SaveReferenceCallback(nullptr){ + + } + virtual ~Archive() {} + virtual bool is_loading() const = 0; + virtual void serialize(void* data, size_t size) = 0; + + virtual size_type get_offset() const = 0; + virtual void set_offset(size_type offset) = 0; + + virtual void flush() {} + + POD_SERIALIZE(uint8_t); + POD_SERIALIZE(uint16_t); + POD_SERIALIZE(uint32_t); + POD_SERIALIZE(uint64_t); + POD_SERIALIZE(int8_t); + POD_SERIALIZE(int16_t); + POD_SERIALIZE(int32_t); + POD_SERIALIZE(int64_t); + POD_SERIALIZE(float); + POD_SERIALIZE(double); + POD_SERIALIZE(lm::float2); + POD_SERIALIZE(lm::float3); + POD_SERIALIZE(lm::float4); + POD_SERIALIZE(lm::double2); + POD_SERIALIZE(lm::double3); + POD_SERIALIZE(lm::double4); + + POD_SERIALIZE(lm::Quaternion_f); + + Archive& operator << (std::string& value) { + uint32_t string_len = 0; + if (is_loading()) { + serialize(&string_len, sizeof(string_len)); + value.resize(string_len); + serialize(&value[0], string_len); + } else { + string_len = value.size(); + serialize(&string_len, sizeof(string_len)); + serialize(&value[0], string_len); + } + return *this; + } + + Archive& operator << (std::wstring& value) { + uint32_t string_len = 0; + if (is_loading()) { + serialize(&string_len, sizeof(string_len)); + value.resize(string_len); + serialize(&value[0], string_len * sizeof(std::wstring::value_type)); + } else { + string_len = value.size(); + serialize(&string_len, sizeof(string_len)); + serialize(&value[0], string_len * sizeof(std::wstring::value_type)); + } + return *this; + } + + template::value>::type> + Archive& operator << (std::shared_ptr& value) { + if (is_loading()) { + AssetFileLink link; + (*this) << link; + if(link.localId == -1) + { + value = nullptr; + }else + { + auto pos = get_offset(); + value = LoadReferenceCallback == nullptr ? nullptr : std::dynamic_pointer_cast(LoadReferenceCallback(link)); + set_offset(pos); + } + + } else { + if (SaveReferenceCallback != nullptr) { + SaveReferenceCallback(value); + } + AssetFileLink link = value == nullptr ? AssetFileLink() : value->GetFileLink(); + (*this) << link; + } + return *this; + } +private: + Archive& operator << (AssetFileLink& value); +}; +#endif // Archive_h__ diff --git a/Src/RenderFramework/Asset.h b/Src/RenderFramework/Asset.h new file mode 100644 index 0000000..089521f --- /dev/null +++ b/Src/RenderFramework/Asset.h @@ -0,0 +1,45 @@ +#ifndef Asset_h__ +#define Asset_h__ + +#include +#include +#include +#include +#include "Guid.h" + +class AssetFileLink { +public: + using LocalFileID = std::uint32_t; + static constexpr LocalFileID InvalidID = -1; + + Guid fileGuid; + LocalFileID localId; + + AssetFileLink():localId(InvalidID){} + + AssetFileLink(const AssetFileLink& link) :fileGuid(link.fileGuid), localId(link.localId) {} + + AssetFileLink(Guid _fileGuid, LocalFileID _localId) :fileGuid(_fileGuid), localId(_localId) {} + + AssetFileLink& operator=(const AssetFileLink& link) { + fileGuid = link.fileGuid; + localId = link.localId; + return *this; + } + + bool operator==(const AssetFileLink& link) const { + return (fileGuid == link.fileGuid) && (localId == link.localId); + } + + bool operator!=(const AssetFileLink& link) const { + return (fileGuid != link.fileGuid) || (localId != link.localId); + } + + bool IsValid() const{ + return (localId != InvalidID) && !fileGuid.IsZero(); + } +}; + + + +#endif // Asset_h__ diff --git a/Src/RenderFramework/AssetDatabase.cpp b/Src/RenderFramework/AssetDatabase.cpp new file mode 100644 index 0000000..cb039b3 --- /dev/null +++ b/Src/RenderFramework/AssetDatabase.cpp @@ -0,0 +1,110 @@ +#include "AssetDatabase.h" +#include +#include +#include "ModelImporter.h" +#include "TextureImporter.h" +#include + +AssetDatabase::AssetDatabase() +{ + _importers.push_back(std::make_shared()); + //_importers.push_back(std::make_shared()); +} + +void AssetDatabase::setRootPath(const std::wstring& path) +{ + _rootAssetsPath = path; +} + +std::wstring AssetDatabase::getFullAssetPath(const std::string& localPathStr) { + std::filesystem::path rootPath(_rootAssetsPath); + std::filesystem::path localPath(localPathStr); + auto fullPath = rootPath / localPath; + auto result = fullPath.wstring(); + return result; +} + +std::wstring AssetDatabase::asset_to_meta_path(const std::wstring& asset_path) +{ + std::filesystem::path src(asset_path); + return src.parent_path().append(src.filename().wstring() + L".meta").wstring(); +} + +void AssetDatabase::register_importer(std::shared_ptr importer) +{ +} + +std::vector> AssetDatabase::load_all_objects(std::shared_ptr asset) +{ + std::vector> result; + auto table = asset->objectsTable; + for (auto& obj : table.objects) + { + result.push_back(LoadObject(AssetFileLink(asset->guid(), obj.localId))); + } + return result; +} + + +std::shared_ptr AssetDatabase::find_importer(const std::wstring& asset_path) const +{ + auto importer = std::find_if(_importers.begin(), _importers.end(), [asset_path](std::shared_ptr im) { return im->can_import(asset_path); }); + if (importer != _importers.end()) + { + return *importer; + } + return nullptr; +} + +Guid AssetDatabase::file_to_guid(const std::wstring& path) const +{ + return AssetMetadata(path).get_guid(); +} + +std::shared_ptr AssetDatabase::open_asset_file(const std::wstring& path) +{ + return std::make_shared(file_to_guid(path), path); +} + +std::shared_ptr AssetDatabase::LoadReference(const AssetFileLink& link) +{ + return LoadObject(link); +} + + +std::wstring guid_to_path(Guid guid) +{//TODO: fix hardcode + return LR"(C:\Users\Sergey\Desktop\Assets\test.asset)"; +} + + +std::shared_ptr AssetDatabase::OpenArchive(Guid guid) +{ //TODO: fix hardcode + if (open_archives.empty()) + { + auto a = std::make_shared(guid, guid_to_path(guid)); + a->input->LoadReferenceCallback = std::bind(&AssetDatabase::LoadReference, this, std::placeholders::_1); + open_archives.push_back(a); + } + return open_archives[0]; +} + +std::shared_ptr AssetDatabase::LoadObject(AssetFileLink link) +{ + auto f = Object::Find(link); + if (f != nullptr) { return f; } + + auto archive = OpenArchive(link.fileGuid); + archive->SeekToFile(link.localId); + + std::wstring type_name; + (*archive->input) << type_name; + + auto obj = ObjectsFactory::instance().create_object(type_name); + obj->SetLink(link); + + obj->serialize(*archive->input); + + + return obj; +} diff --git a/Src/RenderFramework/AssetDatabase.h b/Src/RenderFramework/AssetDatabase.h new file mode 100644 index 0000000..3712997 --- /dev/null +++ b/Src/RenderFramework/AssetDatabase.h @@ -0,0 +1,39 @@ +#ifndef AssetDatabase_h__ +#define AssetDatabase_h__ + +#include +#include +#include + +#include "AssetMetadata.h" +#include "AssetImporter.h" +#include "AssetFile.h" + + +class AssetDatabase{ +public: + static AssetDatabase& get() { + static AssetDatabase instance; + return instance; + } + static std::wstring asset_to_meta_path(const std::wstring& asset_path); + Guid file_to_guid(const std::wstring& path) const; + std::shared_ptr open_asset_file(const std::wstring& path); + void setRootPath(const std::wstring& path); + static void register_importer(std::shared_ptr importer); + std::shared_ptr find_importer(const std::wstring& asset_path) const; + + std::shared_ptr LoadReference(const AssetFileLink& link); + std::shared_ptr OpenArchive(Guid guid); + std::shared_ptr LoadObject(AssetFileLink link); + + std::vector> load_all_objects(std::shared_ptr asset); + + std::wstring getFullAssetPath(const std::string& localPath); +private: + std::vector> open_archives; + AssetDatabase(); + std::vector> _importers; + std::wstring _rootAssetsPath; +}; +#endif // AssetDatabase_h__ diff --git a/Src/RenderFramework/AssetFile.h b/Src/RenderFramework/AssetFile.h new file mode 100644 index 0000000..f550c89 --- /dev/null +++ b/Src/RenderFramework/AssetFile.h @@ -0,0 +1,226 @@ +#ifndef AssetFile_h__ +#define AssetFile_h__ + +#include "InputArchive.h" +#include "OutputArchive.h" +#include "Asset.h" +#include +#include +#include + +namespace fs = std::experimental::filesystem::v1; + +class AssetObjectDescriptor : public Object { +public: + uint64_t localId; + int64_t offset; + uint64_t length; + AssetObjectDescriptor():localId(0), offset(0), length(0) + { + + } + AssetObjectDescriptor(uint64_t _localId, int64_t _offset, uint64_t _length):localId(_localId), offset(_offset), length(_length){ + + } + virtual void serialize(Archive& archive) override { + archive << localId << offset << length; + } + virtual std::wstring get_type_name() const override { + return L"AssetObjectDescriptor"; + } +}; + +class AssetObjectsTable : public Object{ +public: + uint64_t lastId; + std::vector objects; + + AssetObjectsTable():lastId(0) + { + + } + + bool GetFileDescriptor(uint64_t localId, AssetObjectDescriptor& desc){ + for (auto& o : objects) { + if (o.localId == localId) { + desc = o; + return true; + } + } + return false; + } + + bool Contains(uint64_t localId) const { + for (auto& o : objects) { + if (o.localId == localId) { + return true; + } + } + return false; + } + + virtual void serialize(Archive& archive) override { + archive << lastId; + if(archive.is_loading()){ + uint64_t objectsCount = 0; + archive << objectsCount; + objects.clear(); + for(uint64_t i = 0; i < objectsCount; ++i){ + AssetObjectDescriptor d; + d.serialize(archive); + objects.push_back(d); + } + }else{ + uint64_t objectsCount = objects.size(); + archive << objectsCount; + for (auto& o : objects){ + o.serialize(archive); + } + } + } + virtual std::wstring get_type_name() const override { + return L"AssetObjectsTable"; + } +}; + +inline std::shared_ptr CreateMemoryOutArchive(){ + return std::make_shared(std::make_shared(std::ios::in | std::ios::out | std::ios::binary)); +} + +class AssetFile { +public: + typedef uint64_t table_offset_t; + AssetObjectsTable objectsTable; + std::shared_ptr input; + std::shared_ptr output; + std::shared_ptr stream; + + AssetFile(Guid fileGuid, const std::wstring& path):_fileGuid(fileGuid), _path(path){ + OpenFile(false); + + if(stream->is_open()){ + stream->seekg(0, std::ios::end); + if((int)stream->tellg() == 0){ + std::cout << "Empty asset created!" << std::endl; + SaveFooter(); + } + ReadFooter(); + } + //input = std::make_shared(path); + } + + void OpenFile(bool trunc){ + input = nullptr; + output = nullptr; + stream = std::make_shared(_path, (trunc ? std::ios::trunc : std::ios::app) | std::ios::in | std::ios::out | std::ios::binary); + if (stream->is_open()) { + input = std::make_shared(stream); + output = std::make_shared(stream); + } + } + + void CloseFile() + { + input = nullptr; + output = nullptr; + if(stream != nullptr && stream->is_open()){ + stream->close(); + } + stream = nullptr; + } + + void Save(){ + auto tmpOut = CreateMemoryOutArchive(); + //save objects + int64_t objectOffset = 0; + for(auto& v : objectsTable.objects){ + auto object = Object::Find(AssetFileLink(_fileGuid, v.localId)); + + v.offset = objectOffset; + + auto startOffset = objectOffset = tmpOut->GetStream()->tellp(); + //save all loaded objects, copy not loaded + if(object != nullptr){ + auto typeName = object->get_type_name(); + (*tmpOut) << typeName; + object->serialize(*tmpOut); + }else{ + stream->seekg(v.offset, std::ios::beg); + std::vector objectBytes(v.length); + stream->read((char*)&objectBytes[0], objectBytes.size()); + tmpOut->GetStream()->write((char*)&objectBytes[0], objectBytes.size()); + } + objectOffset = tmpOut->GetStream()->tellp(); + v.length = objectOffset - startOffset; + } + + CloseFile(); + OpenFile(true); + + auto content = std::static_pointer_cast(tmpOut->GetStream())->str(); + stream->write(&content[0], content.size()); + stream->seekg(0, std::ios::end); + //save footer + SaveFooter(); + } + + bool SeekToFile(uint64_t fileId) { + AssetObjectDescriptor desc; + if (objectsTable.GetFileDescriptor(fileId, desc)) { + if (desc.offset >= 0) { + stream->seekg(desc.offset, std::ios::beg); + return true; + } + } + return false; + } + + void ReadFooter() + { + std::cout << "Read footer" << std::endl; + //read table offset + auto off = -((std::streamoff)sizeof(table_offset_t)); + stream->seekg(off, std::ios::end); + table_offset_t offset = 0; + (*input) << offset; + + auto table_file_offset = off - (std::streamoff)offset; + stream->seekg(table_file_offset, std::ios::end); + objectsTable.serialize(*input); + } + + void SaveFooter(){ + std::cout << "Save footer" << std::endl; + stream->seekg(0, std::ios::end); + auto tmpArchive = CreateMemoryOutArchive(); + objectsTable.serialize(*tmpArchive); + auto data = std::static_pointer_cast(tmpArchive->GetStream())->str(); + table_offset_t size = data.size(); + stream->write(&data[0], size); + (*output) << size; + + output->flush(); + } + + void AddObject(std::shared_ptr obj){ + if (obj->GetFileLink().IsValid()) { + if (obj->GetFileLink().fileGuid == _fileGuid) { + std::wcout << "Object " << obj->get_name() << " is already in current asset. Can't add twice" << std::endl; + } else { + std::wcout << "Object " << obj->get_name() << " is already in another asset. Can't add." << std::endl; + } + } else { + obj->SetLink(AssetFileLink(_fileGuid, objectsTable.lastId++)); + objectsTable.objects.push_back(AssetObjectDescriptor(obj->GetFileLink().localId, 0, 0)); + } + } + const Guid& guid() const + { + return _fileGuid; + } +private: + Guid _fileGuid; + std::wstring _path; +}; + +#endif // AssetFile_h__ diff --git a/Src/RenderFramework/AssetImporter.h b/Src/RenderFramework/AssetImporter.h new file mode 100644 index 0000000..b66c113 --- /dev/null +++ b/Src/RenderFramework/AssetImporter.h @@ -0,0 +1,14 @@ +#pragma once + +#include +#include +#include + +class AssetImporter { +public: + virtual void import(std::wstring asset_path) = 0; + virtual bool can_import(const std::wstring& path) const = 0; + virtual bool set_parameters(std::wstring params) = 0; + virtual std::wstring get_parameters() const = 0; + virtual std::wstring name() = 0; +}; diff --git a/Src/RenderFramework/AssetManager.cpp b/Src/RenderFramework/AssetManager.cpp new file mode 100644 index 0000000..8f9eb49 --- /dev/null +++ b/Src/RenderFramework/AssetManager.cpp @@ -0,0 +1,73 @@ +#include "AssetManager.h" +#include "LEngine.h" +#include "Texture.h" + +std::shared_ptr AssetManager::_instance = nullptr; + +TexturePtr AssetManager::LoadTexture(const std::wstring& path) const +{ + return {}; + /* + auto renderer = LEngine::Instance()->GetRenderer(); + auto device = renderer->GetDevice(); + + ID3D12ResourcePtr resource; + + std::unique_ptr data; + std::vector srData; + DirectX::LoadDDSTextureFromFile(device.Get(), GetFullAssetPath(path).c_str(), &resource, data, srData); + + //auto cmdList = renderer->BeginCommandList(); + + + //create upload heap + D3D12_RESOURCE_DESC desc; + desc = resource->GetDesc(); + + UINT64 textureUploadBufferSize; + device->GetCopyableFootprints(&desc, 0, srData.size(), 0, nullptr, nullptr, nullptr, &textureUploadBufferSize); + + // now we create an upload heap to upload our texture to the GPU + ID3D12ResourcePtr textureBufferUploadHeap; + auto hr = device->CreateCommittedResource( + &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), // upload heap + D3D12_HEAP_FLAG_NONE, // no flags + &CD3DX12_RESOURCE_DESC::Buffer(textureUploadBufferSize), // resource description for a buffer (storing the image data in this heap just to copy to the default heap) + D3D12_RESOURCE_STATE_GENERIC_READ, // We will copy the contents from this heap to the default heap above + nullptr, + IID_PPV_ARGS(&textureBufferUploadHeap)); + if (FAILED(hr)) + { + FatalError(L"Failed to create upload heap"); + } + textureBufferUploadHeap->SetName(L"Texture Buffer Upload Resource Heap"); + + auto commandList = renderer->BeginCommandList(); + //copy subresource + UpdateSubresources(commandList.Get(), resource.Get(), textureBufferUploadHeap.Get(), 0, 0, srData.size(), &srData[0]); + commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(resource.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE)); + + + renderer->EndCommandList(); + renderer->WaitCommandsQueue(); + + //create shader resource view + auto srvMemory = renderer->getSrvDescriptorsAllocator()->alloc(); + + D3D12_RESOURCE_DESC texDesc; + texDesc = resource->GetDesc(); + + + D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; + srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; + srvDesc.Format = texDesc.Format; + srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MipLevels = texDesc.MipLevels; + device->CreateShaderResourceView(resource.Get(), &srvDesc, srvMemory); + + + auto result = std::make_shared(resource, srvMemory); + + //DirectX::CreateTexture(renderer->GetDevice(), image.GetImages(), image.GetImageCount(), metadata, &resource); + return result;*/ +} diff --git a/Src/RenderFramework/AssetManager.h b/Src/RenderFramework/AssetManager.h new file mode 100644 index 0000000..a8c6ea2 --- /dev/null +++ b/Src/RenderFramework/AssetManager.h @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include "Texture.h" +#include "ForwardDeclarations.h" + +class AssetManager { +public: + static std::shared_ptr Instance() { + if (_instance == nullptr) { + _instance = std::make_shared(); + } + return _instance; + } + + void SetAssetsFolder(const std::wstring& folder) { + _assetsFolder = folder; + } + + std::wstring GetFullAssetPath(const std::wstring& relativePath) const + { + return _assetsFolder + relativePath; + } + TexturePtr LoadTexture(const std::wstring& path) const; +private: + static std::shared_ptr _instance; + std::wstring _assetsFolder; +}; diff --git a/Src/RenderFramework/AssetMetadata.cpp b/Src/RenderFramework/AssetMetadata.cpp new file mode 100644 index 0000000..b9009e6 --- /dev/null +++ b/Src/RenderFramework/AssetMetadata.cpp @@ -0,0 +1,75 @@ +#include "AssetMetadata.h" +#include +#include +#include +#include +#include +#include "AssetDatabase.h" +#include +#include +using namespace Microsoft::WRL; + +AssetMetadata::AssetMetadata(const std::wstring& asset_path) : _asset_path(asset_path) { + _meta_path = AssetDatabase::asset_to_meta_path(_asset_path); + + if (std::filesystem::exists(std::filesystem::path(_meta_path))) { + Load(); + } else { + create(); + Save(); + } +} + +void AssetMetadata::create() { + CoCreateGuid((GUID*)&_guid); + _modification_time = std::filesystem::last_write_time(std::filesystem::path(_asset_path)).time_since_epoch().count(); + _importer = AssetDatabase::get().find_importer(_asset_path); +} + +void AssetMetadata::Load() { + std::wifstream file(_meta_path); + + std::wstring v; + std::getline(file, v); + + std::wstring guid_str; + std::getline(file, guid_str); + _guid = str_to_guid(guid_str); + + std::wstring time_str; + std::getline(file, time_str); + _modification_time = std::stoull(time_str); + + file.close(); +} + +void AssetMetadata::Save() { + std::wofstream file; + file.open(_meta_path, std::ios::trunc); + file << version << std::endl; + file << guid_to_str(_guid) << std::endl; + file << _modification_time << std::endl; + //file << _importer->name(); + file.close(); +} + +Guid AssetMetadata::str_to_guid(const std::wstring& guid) { + Guid iid; + IIDFromString(guid.c_str(), (GUID*)&iid); + return iid; +} + +std::wstring AssetMetadata::guid_to_str(const Guid& guid) { + LPOLESTR guid_str = nullptr; + StringFromIID(*((const GUID*)&guid), &guid_str); + + //Microsoft::WRL::Wrappers::HStringReference + + std::wstring result(guid_str); + CoTaskMemFree(guid_str); + return result; +} + +const Guid& AssetMetadata::get_guid() const { + return _guid; +} \ No newline at end of file diff --git a/Src/RenderFramework/AssetMetadata.h b/Src/RenderFramework/AssetMetadata.h new file mode 100644 index 0000000..e598639 --- /dev/null +++ b/Src/RenderFramework/AssetMetadata.h @@ -0,0 +1,29 @@ +#ifndef AssetMetadata_h__ +#define AssetMetadata_h__ + +#include +#include +#include +#include "Guid.h" +#include "AssetImporter.h" + +class AssetMetadata { +public: + typedef uint64_t file_time_t; + const std::wstring version = L"1.0"; + + AssetMetadata(const std::wstring& asset_path); + void Save(); + void Load(); + static std::wstring guid_to_str(const Guid& guid); + static Guid str_to_guid(const std::wstring& guid); + const Guid& get_guid() const; +private: + std::shared_ptr _importer; + void create(); + std::wstring _asset_path; + std::wstring _meta_path; + file_time_t _modification_time; + Guid _guid; +}; +#endif // AssetMetadata_h__ diff --git a/Src/RenderFramework/Bounds.h b/Src/RenderFramework/Bounds.h new file mode 100644 index 0000000..3ec5f51 --- /dev/null +++ b/Src/RenderFramework/Bounds.h @@ -0,0 +1,44 @@ +#ifndef Bounds_h__ +#define Bounds_h__ + +#include +using namespace lm; + +class Bounds { +public: + Bounds() + :_center(0.0f,0.0f,0.0f), _size(0.0f,0.0f,0.0f) { + + } + Bounds(float3 center, float3 size) + :_center(center), _size(size) + { + + } + + float3 GetSize() { + return _size; + } + float3 GetCenter() { + return _center; + } + void SetSize(const float3& size) { + _size = size; + } + void SetCenter(const float3& center) { + _center = center; + } + void Scale(float value) { + _size *= value; + } + float3 Minimum() const { + return _size * -0.5f + _center; + } + float3 Maximum() const { + return _size * 0.5f + _center; + } +private: + float3 _center; + float3 _size; +}; +#endif // Bounds_h__ diff --git a/Src/RenderFramework/Camera.cpp b/Src/RenderFramework/Camera.cpp new file mode 100644 index 0000000..617a129 --- /dev/null +++ b/Src/RenderFramework/Camera.cpp @@ -0,0 +1,31 @@ +#include "Camera.h" +#include "Transform.h" +#include "Mathf.h" +#include "Archive.h" + +float4x4 Camera::worldToCameraMatrix() { + auto world = transform()->GetGlobalTransform(); + + //TODO: why not affine ? + world = inverse(world, false); + +// auto test = lookatlh(transform()->GetGlobalPosition(), float3(0, 1, 1), float3(0, 1, 0)); + + return world; +} + + + +void Camera::serialize(Archive& archive) { + Component::serialize(archive); + archive << nearClipPlane << farClipPlane << fov << aspect; +} + +void Camera::UpdateProjectionMatrix() { + _projection = matrix4x4Perspective(fov * Mathf::DegToRad(), aspect, nearClipPlane, farClipPlane); +} + +float4x4 Camera::projectionMatrix() { + UpdateProjectionMatrix(); + return _projection; +} diff --git a/Src/RenderFramework/Camera.h b/Src/RenderFramework/Camera.h new file mode 100644 index 0000000..0500408 --- /dev/null +++ b/Src/RenderFramework/Camera.h @@ -0,0 +1,29 @@ +#ifndef Camera_h__ +#define Camera_h__ + +#include "ObjectsFactory.h" +#include +#include "Component.h" +using namespace lm; + +LOBJECT(Camera, Component) +public: + float nearClipPlane = 0.03f; + float farClipPlane = 100.0f; + float fov = 45.0f; + float aspect = 1.333333333f; + + virtual void serialize(Archive& archive) override; + + float4x4 worldToCameraMatrix(); + float4x4 projectionMatrix(); + void test() { + construct(); + } +private: + float4x4 _projection; + void UpdateProjectionMatrix(); +}; + +typedef std::shared_ptr CameraPtr; +#endif // Camera_h__ diff --git a/Src/RenderFramework/Component.cpp b/Src/RenderFramework/Component.cpp new file mode 100644 index 0000000..efa216b --- /dev/null +++ b/Src/RenderFramework/Component.cpp @@ -0,0 +1,18 @@ +#include "Component.h" +#include "GameObject.h" + +TransformPtr Component::transform() { + return gameObject->transform; +} + +void Component::serialize(Archive& archive) { + auto ptr = std::static_pointer_cast(gameObject); + archive << ptr; + + if (archive.is_loading()) { + gameObject = std::static_pointer_cast(ptr); + + } +} + + diff --git a/Src/RenderFramework/Component.h b/Src/RenderFramework/Component.h new file mode 100644 index 0000000..7fb253e --- /dev/null +++ b/Src/RenderFramework/Component.h @@ -0,0 +1,19 @@ +#ifndef Component_h__ +#define Component_h__ + +#include +#include "ObjectsFactory.h" + +LOBJECT(Component, Object) +public: + GameObjectPtr gameObject; + TransformPtr transform(); + virtual void tick(float deltaTime) {} + Component(){} + + void serialize(Archive& archive) override; +}; + + + +#endif // Component_h__ diff --git a/Src/RenderFramework/FatalError.h b/Src/RenderFramework/FatalError.h new file mode 100644 index 0000000..f1e583a --- /dev/null +++ b/Src/RenderFramework/FatalError.h @@ -0,0 +1,19 @@ +#ifndef FatalError_h__ +#define FatalError_h__ + +#include + +inline void FatalError(const TCHAR* message) { + int b1 = 12750; + int b2 = 4750; + int len = 80; + + for(int i = 0; i < 2; ++i) { + Beep(b1, len); + Beep(b2, len); + } + + MessageBox(NULL, message, TEXT("Error"), MB_OK); + exit(0); +} +#endif // FatalError_h__ diff --git a/Src/RenderFramework/File.h b/Src/RenderFramework/File.h new file mode 100644 index 0000000..0f3ca84 --- /dev/null +++ b/Src/RenderFramework/File.h @@ -0,0 +1,71 @@ +#ifndef File_h__ +#define File_h__ + +#include +#include +#include + +uint32_t FileSize(const std::wstring& path) { + std::ifstream file(path, std::ios_base::binary); + if (!file.good()) { + return 0; + } + std::streampos current_position = file.tellg(); + file.seekg(0, std::ios::end); + std::streampos ending_position = file.tellg(); + file.seekg(current_position); + file.close(); + return (uint32_t)(ending_position - current_position); +} + +uint32_t FileSize(const std::string& path) { + std::ifstream file(path, std::ios_base::binary); + if (!file.good()) { + return 0; + } + std::streampos current_position = file.tellg(); + file.seekg(0, std::ios::end); + std::streampos ending_position = file.tellg(); + file.seekg(current_position); + file.close(); + return (uint32_t)(ending_position - current_position); +} + +void FileReadAllText(const std::wstring& path, std::string& result) { + auto size = FileSize(path); + if (size == 0) { + return; + } + + std::ifstream file(path, std::ios::in); + result.reserve(size); + result.assign(std::istreambuf_iterator(file), std::istreambuf_iterator()); + file.close(); +} + +void FileReadAllBytes(const std::wstring& path, std::vector& result) { + auto size = FileSize(path); + if (size == 0) { + return; + } + + std::ifstream file(path, std::ios::in | std::ios::binary); + result.reserve(size); + result.assign(std::istreambuf_iterator(file), std::istreambuf_iterator()); + file.close(); +} + +void FileReadAllBytes(const std::string& path, std::vector& result) { + auto size = FileSize(path); + if (size == 0) { + return; + } + + std::ifstream file(path, std::ios::in | std::ios::binary); + result.reserve(size); + result.assign(std::istreambuf_iterator(file), std::istreambuf_iterator()); + file.close(); +} + + +#endif // File_h__ diff --git a/Src/RenderFramework/Filesystem.h b/Src/RenderFramework/Filesystem.h new file mode 100644 index 0000000..29383eb --- /dev/null +++ b/Src/RenderFramework/Filesystem.h @@ -0,0 +1,14 @@ +#ifndef Filesystem_h__ +#define Filesystem_h__ + +#include +#include + +class Filesystem { +public: + //static std::shared_ptr Create(const std::string& assetsFolder); + +private: + //Filesystem(); +}; +#endif // Filesystem_h__ diff --git a/Src/RenderFramework/ForwardDeclarations.h b/Src/RenderFramework/ForwardDeclarations.h new file mode 100644 index 0000000..48d82bb --- /dev/null +++ b/Src/RenderFramework/ForwardDeclarations.h @@ -0,0 +1,35 @@ +#pragma once + +#include +#include +#include + +class GameObject; +typedef std::shared_ptr GameObjectPtr; + +class Component; +typedef std::shared_ptr ComponentPtr; + +class Scene; +typedef std::shared_ptr ScenePtr; + +class Transform; +typedef std::shared_ptr TransformPtr; + +class Shader; +typedef std::shared_ptr ShaderPtr; + +class Mesh; +typedef std::shared_ptr MeshPtr; + +class Material; +typedef std::shared_ptr MaterialPtr; + +class Mouse; +typedef std::shared_ptr MousePtr; + +class Keyboard; +typedef std::shared_ptr KeyboardPtr; + +class Texture; +typedef std::shared_ptr TexturePtr; \ No newline at end of file diff --git a/Src/RenderFramework/ForwardListItem.h b/Src/RenderFramework/ForwardListItem.h new file mode 100644 index 0000000..5baff48 --- /dev/null +++ b/Src/RenderFramework/ForwardListItem.h @@ -0,0 +1,8 @@ +#ifndef ForwardListItem_h__ +#define ForwardListItem_h__ + +class ForwardListItem{ +public: + ForwardListItem* next; +}; +#endif // ForwardListItem_h__ diff --git a/Src/RenderFramework/GameObject.cpp b/Src/RenderFramework/GameObject.cpp new file mode 100644 index 0000000..15bce53 --- /dev/null +++ b/Src/RenderFramework/GameObject.cpp @@ -0,0 +1,18 @@ + +#include "Transform.h" +#include "LEngine.h" +#include "Component.h" +#include "GameObject.h" + +void GameObject::tick(float deltaTime) { + for (auto c : components) { + c->tick(deltaTime); + } +} + +void GameObject::construct2() { + Object::construct(); + auto this_ptr = std::static_pointer_cast(shared_from_this()); + LEngine::Instance()->GetActiveScene()->objects.push_back(this_ptr); + this_ptr->transform = this_ptr->AddComponent(); +} \ No newline at end of file diff --git a/Src/RenderFramework/GameObject.h b/Src/RenderFramework/GameObject.h new file mode 100644 index 0000000..79b5fdc --- /dev/null +++ b/Src/RenderFramework/GameObject.h @@ -0,0 +1,95 @@ +#ifndef GameObject___h__ +#define GameObject___h__ + +#include "ForwardDeclarations.h" +#include +#include +#include +#include "ObjectsFactory.h" +#include "OutputArchive.h" +#include "Transform.h" + +LOBJECT(GameObject, Object) +public: + TransformPtr transform; + + void tick(float deltaTime); + + virtual void serialize(Archive& archive) override { + Object::serialize(archive); + + if (archive.is_loading()) { + components.clear(); + transform = nullptr; + } + + Archive::size_type cnt = components.size(); + archive << cnt; + + if (archive.is_loading()) { + for (Archive::size_type i = 0; i < cnt; ++i) { + std::shared_ptr obj; + archive << obj; + components.push_back(std::static_pointer_cast(obj)); + + auto tp = std::dynamic_pointer_cast(obj); + if (tp != nullptr) { + transform = tp; + } + } + } else { + for (auto component : components) { + auto ptr = std::static_pointer_cast(component); + archive << ptr; + } + } + } + + std::shared_ptr as_game_object() { + return std::static_pointer_cast(shared_from_this()); + } + + template + std::shared_ptr AddComponent() { + auto component = T::create(); + component->gameObject = as_game_object(); + components.push_back(component); + return component; + } + + template + std::shared_ptr GetComponent() { + for (auto c : components) { + auto tmp = std::dynamic_pointer_cast(c); + if (tmp != nullptr) { + return tmp; + } + } + return nullptr; + } + + template + std::vector> GetComponents() { + std::vector> result; + for (auto c : components) { + auto tmp = std::dynamic_pointer_cast(c); + if (tmp != nullptr) { + result.push_back(tmp); + } + } + return result; + } + + void construct() override { + construct2(); + } + void construct2(); + +private: + GameObject() {} + std::vector components; +}; + + + +#endif // GameObject___h__ diff --git a/Src/RenderFramework/GizmoVertex.h b/Src/RenderFramework/GizmoVertex.h new file mode 100644 index 0000000..b7271b3 --- /dev/null +++ b/Src/RenderFramework/GizmoVertex.h @@ -0,0 +1,24 @@ +#ifndef GizmoVertex_h__ +#define GizmoVertex_h__ + +#include + +using namespace lm; + +struct GizmoVertex { + float4 position; + float4 color; + + GizmoVertex(float4 _position, float4 _color) + :position(_position), color(_color) + { + + } + + GizmoVertex(float3 _position, float4 _color) + :position(_position.x(), _position.y(), _position.z(), 1.0f), color(_color) + { + + } +}; +#endif // GizmoVertex_h__ diff --git a/Src/RenderFramework/Gizmos.cpp b/Src/RenderFramework/Gizmos.cpp new file mode 100644 index 0000000..1cc032a --- /dev/null +++ b/Src/RenderFramework/Gizmos.cpp @@ -0,0 +1,130 @@ +#include "Gizmos.h" +#include "GameObject.h" +#include "LEngine.h" +#include "LEngine.h" + +Gizmos::Gizmos() + :_color(0.0f, 1.0f, 0.0f, 1.0f) +{ + _matrix = float4x4::identity(); +} +void Gizmos::SetMatrix(const float4x4& matrix) { + _matrix = matrix; +} +float4x4 Gizmos::GetMatrix() { + return _matrix; +} +void Gizmos::DrawBounds(const Bounds& bounds) { + auto b = bounds; + b.Scale(1.01f); + auto bMin = b.Minimum(); + auto bMax = b.Maximum(); + + DrawLine(float3(bMin.x(), bMax.y(), bMax.z()), float3(bMax.x(), bMax.y(), bMax.z())); + DrawLine(float3(bMin.x(), bMax.y(), bMin.z()), float3(bMax.x(), bMax.y(), bMin.z())); + DrawLine(float3(bMin.x(), bMax.y(), bMax.z()), float3(bMin.x(), bMax.y(), bMin.z())); + DrawLine(float3(bMax.x(), bMax.y(), bMax.z()), float3(bMax.x(), bMax.y(), bMin.z())); + + DrawLine(float3(bMin.x(), bMin.y(), bMax.z()), float3(bMax.x(), bMin.y(), bMax.z())); + DrawLine(float3(bMin.x(), bMin.y(), bMin.z()), float3(bMax.x(), bMin.y(), bMin.z())); + DrawLine(float3(bMin.x(), bMin.y(), bMax.z()), float3(bMin.x(), bMin.y(), bMin.z())); + DrawLine(float3(bMax.x(), bMin.y(), bMax.z()), float3(bMax.x(), bMin.y(), bMin.z())); + + DrawLine(float3(bMin.x(), bMin.y(), bMin.z()), float3(bMin.x(), bMax.y(), bMin.z())); + DrawLine(float3(bMax.x(), bMin.y(), bMin.z()), float3(bMax.x(), bMax.y(), bMin.z())); + + DrawLine(float3(bMin.x(), bMin.y(), bMax.z()), float3(bMin.x(), bMax.y(), bMax.z())); + DrawLine(float3(bMax.x(), bMin.y(), bMax.z()), float3(bMax.x(), bMax.y(), bMax.z())); + +} +void Gizmos::Init() { + /*_backMaterial = Material::Create(Shader::Create(L"shaders/gizmos.fx"), "gizmo_back"); + + _frontMaterial = Material::Create(_backMaterial->GetShader(), "gizmo_front"); + + _backMaterial->GetParametersBlock().SetValue("alphaMul", 0.2f); + _frontMaterial->GetParametersBlock().SetValue("alphaMul", 1.0f); + + D3D11_INPUT_ELEMENT_DESC ied[] = { + { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 }, + }; + + auto vs = _backMaterial->GetShader()->GetShader(ShaderType::Vs); + auto device = LEngine::Instance()->GetRenderer()->GetDevice(); + auto hr = device->CreateInputLayout(ied, 2, vs->blob->GetBufferPointer(), vs->blob->GetBufferSize(), &_inputLayout); + + D3D11_DEPTH_STENCIL_DESC desc; + d3d11_helper::DefaultDepthStencilDesc(desc); + hr = device->CreateDepthStencilState(&desc, &_frontLineDepthState); + desc.DepthFunc = D3D11_COMPARISON_GREATER; + hr = device->CreateDepthStencilState(&desc, &_backLineDepthState);*/ +} +void Gizmos::DrawLine(const float3& from, const float3& to) { + /*_vertices.push_back(GizmoVertex(lm::mul(_matrix, from), _color)); + _vertices.push_back(GizmoVertex(lm::mul(_matrix, to), _color));*/ +} +void Gizmos::DrawAll(CameraPtr camera) { + /*auto renderer = LEngine::Instance()->GetRenderer(); + + renderer->GetImmediateContext()->OMSetDepthStencilState(_frontLineDepthState, 0); + DrawImpl(camera, _frontMaterial); + renderer->GetImmediateContext()->OMSetDepthStencilState(_backLineDepthState, 0); + DrawImpl(camera, _backMaterial); + renderer->GetImmediateContext()->OMSetDepthStencilState(_frontLineDepthState, 0);*/ +} +void Gizmos::DrawImpl(CameraPtr camera, MaterialPtr material) { + /*if (_vertices.size() < 2) { + return; + } + //set system variables + auto& params = material->GetParametersBlock(); + float4x4 matrix = float4x4::identity(); + params.SetValue("mWorld", matrix); + params.SetValue("mView", camera->worldToCameraMatrix()); + params.SetValue("mProjection", camera->projectionMatrix()); + + auto renderer = LEngine::Instance()->GetRenderer(); + + material->Apply(renderer->GetImmediateContext()); + + ID3D11Buffer* vb[1] = { _vertexBuffer }; + UINT stride = sizeof(GizmoVertex); + UINT offset = 0; + + renderer->GetImmediateContext()->IASetInputLayout(_inputLayout); + renderer->GetImmediateContext()->IASetVertexBuffers(0, 1, vb, &stride, &offset); + renderer->GetImmediateContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST); + renderer->GetImmediateContext()->Draw(_vertices.size(), 0);*/ +} +void Gizmos::Clear() { + /*_vertices.clear(); + _matrix = float4x4::identity();*/ +} +void Gizmos::PrepareRender() { + /*_vertexBuffer = nullptr; + + if (_vertices.size() < 2) { + return; + } + //vertex buffer + D3D11_BUFFER_DESC desc = { 0 }; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.ByteWidth = sizeof(_vertices[0])* _vertices.size(); + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + D3D11_SUBRESOURCE_DATA data; + data.pSysMem = &_vertices[0]; + data.SysMemPitch = 0; + + _vertexBuffer = nullptr; + LEngine::Instance()->GetRenderer()->GetDevice()->CreateBuffer(&desc, &data, &_vertexBuffer);*/ +} +float4 Gizmos::GetColor() { + return _color; +} +void Gizmos::SetColor(float4 color) { + _color = color; +} \ No newline at end of file diff --git a/Src/RenderFramework/Gizmos.h b/Src/RenderFramework/Gizmos.h new file mode 100644 index 0000000..0c8b72b --- /dev/null +++ b/Src/RenderFramework/Gizmos.h @@ -0,0 +1,37 @@ +#pragma once + +#include "GizmoVertex.h" +#include +#include "Material.h" +#include "Shader.h" +#include +#include "Camera.h" +#include "Bounds.h" + +using namespace lm; + +class Gizmos { +public: + Gizmos(); + void Init(); + void DrawLine(const float3& from, const float3& to); + void DrawBounds(const Bounds& bounds); + void DrawAll(CameraPtr camera); + void Clear(); + void PrepareRender(); + float4 GetColor(); + void SetColor(float4 color); + void SetMatrix(const float4x4& matrix); + float4x4 GetMatrix(); +private: + void DrawImpl(CameraPtr camera, MaterialPtr material); + //ID3D11InputLayoutPtr _inputLayout; + //ID3D11BufferPtr _vertexBuffer; + //ID3D11DepthStencilStatePtr _backLineDepthState; + //ID3D11DepthStencilStatePtr _frontLineDepthState; + MaterialPtr _backMaterial; + MaterialPtr _frontMaterial; + float4 _color; + float4x4 _matrix; + std::vector _vertices; +}; diff --git a/Src/RenderFramework/Guid.h b/Src/RenderFramework/Guid.h new file mode 100644 index 0000000..dd284d6 --- /dev/null +++ b/Src/RenderFramework/Guid.h @@ -0,0 +1,43 @@ +#ifndef Guid_h__ +#define Guid_h__ + +#include +#include + +struct Guid { + union { + std::array data; + std::array datai; + }; + + Guid() :datai{ 0,0,0,0 } { + + } + Guid(uint32_t i0, uint32_t i1, uint32_t i2, uint32_t i3) : datai{ i0,i1,i2,i3 } { + + } + Guid(const std::array& data_i) : datai(data_i) { + + } + Guid(const std::array& data) : data(data) { + + } + Guid(const Guid& guid) : data(guid.data) { + + } + Guid& operator =(const Guid& right) { + data = right.data; + return *this; + } + bool operator ==(const Guid& right) const { + return std::equal(data.begin(), data.end(), right.data.begin()); + } + bool operator !=(const Guid& right) const { + return !std::equal(data.begin(), data.end(), right.data.begin()); + } + bool IsZero() const { + return (datai[0] == 0) && (datai[1] == 0) && (datai[2] == 0) && (datai[3] == 0); + } +}; + +#endif // Guid_h__ diff --git a/Src/RenderFramework/InputArchive.h b/Src/RenderFramework/InputArchive.h new file mode 100644 index 0000000..6e64db2 --- /dev/null +++ b/Src/RenderFramework/InputArchive.h @@ -0,0 +1,49 @@ +#ifndef InputArchive_h__ +#define InputArchive_h__ + + +#include "Archive.h" +#include "Object.h" +#include +#include +#include +#include + +class InputArchive : public Archive { +public: + InputArchive(std::shared_ptr stream) + :_stream(stream) { + } + + virtual bool is_loading() const override { + return true; + } + + virtual void serialize(void* data, size_t size) override { + + _stream->read(reinterpret_cast(data), size); + if(!_stream) + { + + } + } + + size_type get_offset() const override + { + return _stream->tellg(); + } + + void set_offset(size_type offset) override { + _stream->seekg(offset, std::ios::beg); + } + + ~InputArchive() {} + + std::shared_ptr GetStream(){ + return _stream; + } +private: + std::shared_ptr _stream; +}; + +#endif // InputArchive_h__ diff --git a/Src/RenderFramework/LEngine.cpp b/Src/RenderFramework/LEngine.cpp new file mode 100644 index 0000000..805c15c --- /dev/null +++ b/Src/RenderFramework/LEngine.cpp @@ -0,0 +1,26 @@ +#include "LEngine.h" +#include "AssetManager.h" + +std::shared_ptr LEngine::_instance = nullptr; + +std::shared_ptr LEngine::Instance() { + if (_instance == nullptr) { + _instance = std::shared_ptr(new LEngine()); + } + return _instance; +} + +ScenePtr LEngine::GetActiveScene() { + return _activeScene; +} + +void LEngine::Init(const std::wstring& assetsPath) { + AssetManager::Instance()->SetAssetsFolder(assetsPath); + _renderer->Init(); +} + +void LEngine::LoadScene(const std::string& path) { + _activeScene = nullptr; + _activeScene = std::make_shared(); + _activeScene->SetName("New scene"); +} \ No newline at end of file diff --git a/Src/RenderFramework/LEngine.h b/Src/RenderFramework/LEngine.h new file mode 100644 index 0000000..73be2da --- /dev/null +++ b/Src/RenderFramework/LEngine.h @@ -0,0 +1,37 @@ +#ifndef Application_h__ +#define Application_h__ + +#include "Scene.h" +#include "ForwardDeclarations.h" +#include +#include "Renderer.h" +#include "RenderOutput.h" + +class LEngine { +public: + static std::shared_ptr Instance(); + friend class Scene; + ScenePtr GetActiveScene(); + void LoadScene(const std::string& path); + void Init(const std::wstring& assetsPath); + RendererPtr& GetRenderer() { + return _renderer; + } + void AddOutput(RenderOutputPtr output) { + _outputs.push_back(output); + } + std::vector GetOutputs() { + return _outputs; + } +private: + LEngine() + { + _renderer = std::make_shared(); + } + RendererPtr _renderer; + ScenePtr _activeScene; + static std::shared_ptr _instance; + std::vector _outputs; +}; + +#endif // Application_h__ diff --git a/Src/RenderFramework/Material.cpp b/Src/RenderFramework/Material.cpp new file mode 100644 index 0000000..982f240 --- /dev/null +++ b/Src/RenderFramework/Material.cpp @@ -0,0 +1,197 @@ +#include "Material.h" +#include +#include +//#include +#include +#include +#include "FatalError.h" + +void Material::SetShader(ShaderPtr _shader) { + shader = _shader; + RebuildBuffers(); +} + +std::string Material::DiffuseMapName() { + return "_DiffuseMap"; +} +std::string Material::NormalMapName() { + return "_NormalMap"; +} +std::string Material::DiffuseColorName() { + return "_DiffuseColor"; +} +MaterialPtr Material::Create(std::string name) { + return std::shared_ptr(new Material(name)); +} + +MaterialPtr Material::Create(ShaderPtr shader, std::string name) { + auto material = Create(name); + material->SetShader(shader); + return material; +} + +void Material::Apply() { + for(int i = 0; i < (int)ShaderType::Count; ++i) { + auto s = shader->GetShader((ShaderType)i); + if(s != nullptr) { + + //apply shaders + //s->Apply(context); + + auto& p = shaderParameters[i]; + //update and apply buffers + for (auto& bufferCtx : p.buffers) { + + D3D12_RANGE range; + range.Begin = range.End = 0; + + uint8_t* data = nullptr; + + // auto hr = bufferCtx.buffer->Map(0, &range, (void**)&data); + // assert(hr == S_OK); + + //write all variables + for (auto& variable : bufferCtx.variables) { + auto param = parameters.GetParameterByName(variable.name); + if (param != nullptr) { + memcpy(data + variable.offset, param->GetPointer(), variable.size); + } + } + + range.End = bufferCtx.size; + // bufferCtx.buffer->Unmap(0, &range); + // assert(hr == S_OK); + /*context->Unmap(bufferCtx.buffer, 0); + ID3D11Buffer* buffers[1] = { bufferCtx.buffer }; + + switch ((ShaderType)i) + { + case ShaderType::Vs: + context->VSSetConstantBuffers(bufferCtx.bindPoint, 1, buffers); + break; + case ShaderType::Ps: + context->PSSetConstantBuffers(bufferCtx.bindPoint, 1, buffers); + break; + default: + assert(false && "not implemented"); + }*/ + + //sr.pData + + } + + //apply shader resources + /*for (auto& resourceCtx : p.resources) { + auto param = parameters.GetParameterByName(resourceCtx.name); + if (param != nullptr) { + auto resourceParam = std::dynamic_pointer_cast(param); + + ID3D11ShaderResourceView* resources[1] = { resourceParam->value }; + + switch ((ShaderType)i) + { + case ShaderType::Vs: + context->VSSetShaderResources(resourceCtx.bindPoint, 1, resources); + break; + case ShaderType::Ps: + context->PSSetShaderResources(resourceCtx.bindPoint, 1, resources); + break; + default: + assert(false && "not implemented"); + } + } + + }*/ + + } else { + + } + } +} + +void Material::RebuildShaderParameters(ShaderParametersContext& params, ComPtr reflection) { + + + D3D12_SHADER_DESC d; + reflection->GetDesc(&d); + + params.Clear(); + + //get resource variables + for(uint32_t i = 0; i < d.BoundResources; ++i) { + D3D12_SHADER_INPUT_BIND_DESC bindDesc; + reflection->GetResourceBindingDesc(i, &bindDesc); + + ShaderResourceVariable var; + var.bindPoint = bindDesc.BindPoint; + var.name = bindDesc.Name; + var.type = bindDesc.Type; + params.resources.push_back(var); + } + + + //get constant buffers + for(uint32_t i = 0; i < d.ConstantBuffers; ++i) { + ShaderBufferContext ctx; + ID3D12ShaderReflectionConstantBuffer* cb = reflection->GetConstantBufferByIndex(i); + + auto device = shader->GetDevice(); + D3D12_SHADER_BUFFER_DESC bufferDesc; + cb->GetDesc(&bufferDesc); + + ctx.name = bufferDesc.Name; + + D3D11_BUFFER_DESC cbDesc; + cbDesc.ByteWidth = bufferDesc.Size; + cbDesc.Usage = D3D11_USAGE_DYNAMIC; + cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + cbDesc.MiscFlags = 0; + cbDesc.StructureByteStride = 0; + + + // auto hr = device->CreateCommittedResource( + // &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), // this heap will be used to upload the constant buffer data + // D3D12_HEAP_FLAG_NONE, // no flags + // &CD3DX12_RESOURCE_DESC::Buffer(1024 * 64), // Must be a multiple of 64KB for single-textures and constant buffers. TODO: handle size overflow o_O Maybe. + // D3D12_RESOURCE_STATE_GENERIC_READ, + // nullptr, + // IID_PPV_ARGS(&ctx.buffer)); + + // ctx.buffer->SetName(L"Constant Buffer Upload Resource Heap"); + + + //device->CreateBuffer(&cbDesc, nullptr, &ctx.buffer); + + for(uint32_t j = 0; j < bufferDesc.Variables; ++j) { + auto variable = cb->GetVariableByIndex(j); + D3D12_SHADER_VARIABLE_DESC varDesc; + variable->GetDesc(&varDesc); + ctx.variables.push_back(ShaderBufferVariable(varDesc.Name, varDesc.StartOffset, varDesc.Size)); + } + + //find buffer's bind point + + // auto res = Where(params.resources, [ctx](ShaderResourceVariable srv) {return srv.name == ctx.name && srv.type == D3D_SIT_CBUFFER; })->ToVector(); + // ctx.bindPoint = res[0].bindPoint; + // ctx.type = res[0].type; + // ctx.size = cbDesc.ByteWidth; + // params.buffers.push_back(ctx); + } +} + +void Material::RebuildBuffers() { + ComPtr reflection; + for(int i = 0; i < (int)ShaderType::Count; ++i) { + auto vs = shader->GetShader((ShaderType)i); + if(vs != nullptr) { + reflection = nullptr; + D3DReflect(vs->blob->GetBufferPointer(), vs->blob->GetBufferSize(), __uuidof(reflection), (void**)&reflection); + RebuildShaderParameters(shaderParameters[i], reflection); + } + } +} + +void Material::SetParametersBlock(ShaderParametersBlock& block) { + parameters = block; +} \ No newline at end of file diff --git a/Src/RenderFramework/Material.h b/Src/RenderFramework/Material.h new file mode 100644 index 0000000..f642875 --- /dev/null +++ b/Src/RenderFramework/Material.h @@ -0,0 +1,57 @@ +#ifndef Material_h__ +#define Material_h__ + +#include "Shader.h" +#include +#include +#include +#include "ForwardDeclarations.h" +#include "ShaderParametersBlock.h" +#include "Object.h" + +#include + +using namespace Microsoft::WRL; + +class Material : public Object { +public: + std::wstring class_name() const { + return L"Material"; + } + void SetShader(ShaderPtr _shader); + ShaderPtr GetShader() { + return shader; + } + void SetParametersBlock(ShaderParametersBlock& block); + ShaderParametersBlock& GetParametersBlock() { + return parameters; + } + void Apply(); + static MaterialPtr Create(std::string name); + static MaterialPtr Create(ShaderPtr shader, std::string name); + static std::string DiffuseMapName(); + static std::string NormalMapName(); + static std::string DiffuseColorName(); + ShaderParametersContext& GetCompiledParameters(ShaderType shader_type) + { + return shaderParameters[(uint32_t)shader_type]; + } +private: + + Material(std::string name) + :_name(name) + { + + } + std::string _name; + ShaderPtr shader; + ShaderParametersContext shaderParameters[(uint32_t)ShaderType::Count]; + ShaderParametersBlock parameters; + + + void RebuildBuffers(); + void RebuildShaderParameters(ShaderParametersContext& params, ComPtr reflection); +}; + + +#endif // Material_h__ diff --git a/Src/RenderFramework/Mathf.h b/Src/RenderFramework/Mathf.h new file mode 100644 index 0000000..5d1d090 --- /dev/null +++ b/Src/RenderFramework/Mathf.h @@ -0,0 +1,14 @@ +#pragma once + +class Mathf { +public: + static float Pi() { + return 3.1415926535897932384626f; + } + static float RadToDeg() { + return 180.0f / Pi(); + } + static float DegToRad() { + return Pi() / 180.0f; + } +}; \ No newline at end of file diff --git a/Src/RenderFramework/Mesh.cpp b/Src/RenderFramework/Mesh.cpp new file mode 100644 index 0000000..6bf3de0 --- /dev/null +++ b/Src/RenderFramework/Mesh.cpp @@ -0,0 +1,148 @@ +#include "Mesh.h" +#include "LEngine.h" +#include + +// Mesh::Mesh(ID3D12DevicePtr dev) { +// _device = dev; +// SetSubmeshCount(1); +// } + +MeshPtr Mesh::Create() { + return nullptr;//std::shared_ptr(new Mesh(LEngine::Instance()->GetRenderer()->GetDevice())); +} + +// ID3D12ResourcePtr Mesh::GetVertexBuffer() { +// return _vertexBuffer; +// } + +// ID3D12DevicePtr Mesh::GetDevice() { +// return _device; +// } + +MeshPtr Mesh::Create(MeshProcessFunction initFunction) { + auto mesh = Create(); + if (initFunction != nullptr) { + initFunction(mesh); + mesh->RecalculateBounds(); + } + return mesh; +} + +Bounds Mesh::GetBounds() const { + return _bounds; +} + +std::vector Mesh::GetVertices() { + std::vector result; + /*if (_vertexBuffer == nullptr) { + return result; + } + + D3D11_BUFFER_DESC desc; + _vertexBuffer->GetDesc(&desc); + desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + ID3D11BufferPtr stagingBuffer; + _device->CreateBuffer(&desc, nullptr, &stagingBuffer); + ID3D11DeviceContextPtr ctx; + _device->GetImmediateContext(&ctx); + + ctx->CopyResource(stagingBuffer, _vertexBuffer); + D3D11_MAPPED_SUBRESOURCE sr; + ctx->Map(stagingBuffer, 0, D3D11_MAP_READ, 0, &sr); + result.resize(desc.ByteWidth / sizeof(Vertex)); + memcpy_s(&result[0], desc.ByteWidth, sr.pData, desc.ByteWidth); + ctx->Unmap(stagingBuffer, 0);*/ + return result; +} + +D3D12_VERTEX_BUFFER_VIEW Mesh::GetVertexBufferView(){ + D3D12_VERTEX_BUFFER_VIEW result; + // result.BufferLocation = _vertexBuffer->GetGPUVirtualAddress(); + result.SizeInBytes = _vertexCount * sizeof(Vertex); + result.StrideInBytes = sizeof(Vertex); + return result; +} + +void Mesh::SetVertices(const std::vector& vertices) { + auto bytesCount = sizeof(vertices[0])* vertices.size(); + _vertexCount = vertices.size(); + + + //create vertex buffer + // _device->CreateCommittedResource( + // &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), + // D3D12_HEAP_FLAG_NONE, + // &CD3DX12_RESOURCE_DESC::Buffer(bytesCount), + // D3D12_RESOURCE_STATE_COPY_DEST, + // nullptr, + // IID_PPV_ARGS(&_vertexBuffer)); + + + //create upload buffer + ComPtr vBufferUploadHeap; + // _device->CreateCommittedResource( + // &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), + // D3D12_HEAP_FLAG_NONE, + // &CD3DX12_RESOURCE_DESC::Buffer(bytesCount), + // D3D12_RESOURCE_STATE_GENERIC_READ, + // nullptr, + // IID_PPV_ARGS(&vBufferUploadHeap)); + // vBufferUploadHeap->SetName(L"Vertex Buffer Upload Resource Heap"); + + + D3D12_SUBRESOURCE_DATA vertexData = {}; + vertexData.pData = reinterpret_cast(&vertices[0]); // pointer to our vertex array + vertexData.RowPitch = bytesCount; // size of all our triangle vertex data + vertexData.SlicePitch = bytesCount; // also the size of our triangle vertex data + + + auto renderer = LEngine::Instance()->GetRenderer(); + // auto cl = renderer->BeginCommandList(); + // UpdateSubresources(cl.Get(), _vertexBuffer.Get(), vBufferUploadHeap.Get(), 0, 0, 1, &vertexData); + // cl->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(_vertexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER)); + renderer->EndCommandList(); + renderer->WaitCommandsQueue(); +} + +void Mesh::SetIndices(const Submesh::index_array_t& indices, MeshTopology topology, uint32_t submeshId) { + if (submeshId >= GetSubmeshCount()) { + return; + } + _submeshes[submeshId]->Set(indices, topology); +} + +uint32_t Mesh::GetSubmeshCount() const { + return _submeshes.size(); +} +void Mesh::SetSubmeshCount(uint32_t count) { + auto oldSize = _submeshes.size(); + _submeshes.resize(count); + for (auto i = oldSize; i < count; ++i) { + _submeshes[i] = std::make_shared(); + } +} + +const std::vector& Mesh::GetSubmeshes() { + return _submeshes; +} + +void Mesh::RecalculateBounds() { + /*auto vertices = GetVertices(); + if (vertices.size() == 0) { + _bounds.SetSize(float3(0, 0, 0)); + _bounds.SetCenter(float3(0, 0, 0)); + } + + float3 minPoint = vertices[0].position.xyz; + float3 maxPoint = vertices[0].position.xyz; + + for (size_t i = 1; i < vertices.size(); ++i) { + minPoint = lm::min(minPoint, vertices[i].position.xyz); + maxPoint = lm::max(maxPoint, vertices[i].position.xyz); + } + + _bounds.SetCenter((minPoint + maxPoint) * 0.5f); + _bounds.SetSize(maxPoint - minPoint);*/ +} \ No newline at end of file diff --git a/Src/RenderFramework/Mesh.h b/Src/RenderFramework/Mesh.h new file mode 100644 index 0000000..b47f44a --- /dev/null +++ b/Src/RenderFramework/Mesh.h @@ -0,0 +1,49 @@ +#ifndef Mesh_h__ +#define Mesh_h__ + +#include +#include +#include +#include +#include "ForwardDeclarations.h" +#include "Vertex.h" +#include "Submesh.h" +#include "Bounds.h" +#include "Object.h" + +#include + +using namespace Microsoft::WRL; + +typedef std::function MeshProcessFunction; + +class Mesh : public Object { +public: + Mesh():_vertexCount(0) + { + + } + std::vector GetVertices(); + void SetVertices(const std::vector& vertices); + void SetIndices(const Submesh::index_array_t& indices, MeshTopology topology, uint32_t submeshId); + void RecalculateBounds(); + // ID3D12ResourcePtr GetVertexBuffer(); + // ID3D12DevicePtr GetDevice(); + static MeshPtr Create(); + static MeshPtr Create(MeshProcessFunction initFunction); + uint32_t GetSubmeshCount() const; + void SetSubmeshCount(uint32_t count); + const std::vector& GetSubmeshes(); + Bounds GetBounds() const; + D3D12_VERTEX_BUFFER_VIEW GetVertexBufferView(); +private: + size_t _vertexCount; + Bounds _bounds; + // Mesh(ID3D12DevicePtr dev); + // ID3D12ResourcePtr _vertexBuffer; + // ID3D12DevicePtr _device; + std::vector _submeshes; +}; + + +#endif // Mesh_h__ diff --git a/Src/RenderFramework/MeshGenerator.cpp b/Src/RenderFramework/MeshGenerator.cpp new file mode 100644 index 0000000..c642cae --- /dev/null +++ b/Src/RenderFramework/MeshGenerator.cpp @@ -0,0 +1,80 @@ +#include "MeshGenerator.h" +#include + +void MeshGenerator::Cube(MeshPtr mesh, bool splitFaces){ + if (mesh == nullptr) { + return; + } + + std::vector vertices; + std::vector indices; + + float3 corners[8]; + for (int i = 0; i < 2; ++i) { + for (int j = 0; j < 4; ++j) { + int id = i * 4 + j; + corners[id].x() = ((j == 0) || (j == 3)) ? -0.5f : 0.5f; + corners[id].y() = -((float)(j >> 1) - 0.5f); + corners[id].z() =(float)i - 0.5f; + } + } + + int vid[] = { 0,1,2,3, 5,4,7,6, 1,5,6,2, 4,0,3,7, 4,5,1,0, 3,2,6,7 }; + for (int i = 0; i < 24; ++i) { + Vertex v; + v.position.x() = corners[vid[i]].x(); + v.position.y() = corners[vid[i]].y(); + v.position.z() = corners[vid[i]].z(); + vertices.push_back(v); + } + + float3 normals[6] = { float3(0.0f,0.0f,-1.0f), float3(0.0f,0.0f,1.0f), float3(1.0f,0.0f,0.0f), float3(-1.0f,0.0f,0.0f), float3(0.0f,1.0f,0.0f), float3(0.0f,-1.0f,0.0f) }; + int indicesBase[] = { 0,1,3,1,2,3 }; + float2 uvBase[] = { float2(0.0f,0.0f), float2(1.0f,0.0f), float2(1.0f,1.0f), float2(0.0f,1.0f) }; + + mesh->SetSubmeshCount(splitFaces ? 6 : 1); + + for (int i = 0; i < 6; ++i) { + for (int j = 0; j < 4; ++j) { + vertices[i * 4 + j].normal = normals[i]; + vertices[i * 4 + j].uv0 = uvBase[j]; + } + + for (int j = 0; j < 6; ++j) { + indices.push_back(indicesBase[j] + i * 4); + } + + if (splitFaces) { + mesh->SetIndices(indices, MeshTopology::TriangleList, i); + indices.resize(0); + } + } + + mesh->SetVertices(vertices); + + if (!splitFaces) { + mesh->SetIndices(indices, MeshTopology::TriangleList, 0); + } +} + +void MeshGenerator::Plane(MeshPtr mesh) { + if (mesh == nullptr) { + return; + } + + float3 normal(0.0f, 1.0f, 0.0f); + float extend = 0.5f; + + std::vector vertices = { + Vertex(float4(-extend, 0.0f, extend, 1.0f), normal, float2(0.0f,0.0f)), + Vertex(float4(extend, 0.0f, extend, 1.0f), normal, float2(1.0f,0.0f)), + Vertex(float4(extend, 0.0f, -extend, 1.0f), normal, float2(1.0f,1.0f)), + Vertex(float4(-extend, 0.0f, -extend, 1.0f), normal, float2(0.0f,1.0f)), + }; + + std::vector indices = { 0,1,3,1,2,3 }; + + mesh->SetSubmeshCount(1); + mesh->SetVertices(vertices); + mesh->SetIndices(indices, MeshTopology::TriangleList, 0); +} \ No newline at end of file diff --git a/Src/RenderFramework/MeshGenerator.h b/Src/RenderFramework/MeshGenerator.h new file mode 100644 index 0000000..6c9c722 --- /dev/null +++ b/Src/RenderFramework/MeshGenerator.h @@ -0,0 +1,15 @@ +#ifndef MeshGenerator_h__ +#define MeshGenerator_h__ + +#include "Mesh.h" +#include "ForwardDeclarations.h" + +class MeshGenerator +{ +public: + static void Cube(MeshPtr mesh, bool splitFaces); + + static void Plane(MeshPtr mesh); +}; +#endif // MeshGenerator_h__ + diff --git a/Src/RenderFramework/MeshRenderer.cpp b/Src/RenderFramework/MeshRenderer.cpp new file mode 100644 index 0000000..7600289 --- /dev/null +++ b/Src/RenderFramework/MeshRenderer.cpp @@ -0,0 +1,54 @@ +#include "MeshRenderer.h" +#include + +void MeshRenderer::SyncMaterialSlots() { + if (mesh == nullptr) { + _materials.resize(0); + } + else { + _materials.resize(mesh->GetSubmeshCount()); + } +} + +std::shared_ptr MeshRenderer::SetMesh(MeshPtr m) { + mesh = m; + SyncMaterialSlots(); + UpdateInputLayouts(); + return std::static_pointer_cast(shared_from_this()); +} + +MeshPtr MeshRenderer::GetMesh() { + return mesh; +} + +void MeshRenderer::SetMaterial(MaterialPtr material, int id){ + SyncMaterialSlots(); + _materials[id] = material; + UpdateInputLayouts(); +} + +void MeshRenderer::UpdateInputLayouts(){ + + if (mesh == nullptr) { + return; + } + + if (_materials.size() == 0 || _materials[0] == nullptr) { + return; + } + + //D3D12_APPEND_ALIGNED_ELEMENT + _inputElements.clear(); + _inputElements.push_back({ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }); + _inputElements.push_back({ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 16, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }); + _inputElements.push_back({ "UV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }); + _inputElements.push_back({ "UV", 1, DXGI_FORMAT_R32G32_FLOAT, 0, 36, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }); + + + _inputLayoutDesc.NumElements = _inputElements.size(); + _inputLayoutDesc.pInputElementDescs = &_inputElements[0]; + + //auto vs = _materials[0]->GetShader()->GetShader(ShaderType::Vs); + //auto hr = mesh->GetDevice()->CreateInputLayout(ied, 4, vs->blob->GetBufferPointer(), vs->blob->GetBufferSize(), &_inputLayout); + //assert(hr == S_OK); +} diff --git a/Src/RenderFramework/MeshRenderer.h b/Src/RenderFramework/MeshRenderer.h new file mode 100644 index 0000000..43f7783 --- /dev/null +++ b/Src/RenderFramework/MeshRenderer.h @@ -0,0 +1,31 @@ +#ifndef MeshRenderer_h__ +#define MeshRenderer_h__ + +#include "ObjectsFactory.h" +#include "Mesh.h" +#include "Material.h" +#include +#include "ForwardDeclarations.h" +#include + + +LOBJECT(MeshRenderer, Component) +public: + std::shared_ptr SetMesh(MeshPtr m); + MeshPtr GetMesh(); + void SetMaterial(MaterialPtr material, int id); + std::vector GetMaterials() { + return _materials; + } + D3D12_INPUT_LAYOUT_DESC GetInputLayout() { + return _inputLayoutDesc; + } +private: + void UpdateInputLayouts(); + void SyncMaterialSlots(); + MeshPtr mesh; + std::vector _materials; + std::vector _inputElements; + D3D12_INPUT_LAYOUT_DESC _inputLayoutDesc; +}; +#endif // MeshRenderer_h__ diff --git a/Src/RenderFramework/ModelImporter.h b/Src/RenderFramework/ModelImporter.h new file mode 100644 index 0000000..2f74955 --- /dev/null +++ b/Src/RenderFramework/ModelImporter.h @@ -0,0 +1,34 @@ +#pragma once + +#include "AssetImporter.h" +#include +#include +#include +#include "ObjMeshLoader.h" +#include "AssetDatabase.h" + +class ModelImporter : public AssetImporter { +public: + virtual bool can_import(const std::wstring& path) const override { + std::filesystem::path src_path(path); + return src_path.extension() == ".obj"; + } + + virtual std::wstring name() override { + return L"ModelImporter"; + } + + virtual bool set_parameters(std::wstring params) override { + return false; + } + + virtual std::wstring get_parameters() const override { + return L""; + } + + virtual void import(std::wstring asset_path) override { + ObjMeshLoader loader; + loader.Load(asset_path); + } + +}; diff --git a/Src/RenderFramework/ObjMeshLoader.h b/Src/RenderFramework/ObjMeshLoader.h new file mode 100644 index 0000000..b3442a8 --- /dev/null +++ b/Src/RenderFramework/ObjMeshLoader.h @@ -0,0 +1,416 @@ +#pragma once + +#include "Mesh.h" +#include "GameObject.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "MeshRenderer.h" +using namespace lm; + + +struct ObjVertex { + int32_t vid; + int32_t tid; + int32_t nid; +}; + +struct ObjFace { + int32_t sid; + int32_t mid; + std::array vertices; +}; + +class ObjGroup { +public: + ObjGroup(std::string objName) + :name(objName), smoothGroupsEnabled(true), activeSmoothGroup(0) + { + + } + void AddFace(int32_t matId, const ObjVertex& v0, const ObjVertex& v1, const ObjVertex& v2) { + ObjFace f; + f.vertices[0] = v0; + f.vertices[1] = v1; + f.vertices[2] = v2; + f.mid = matId; + f.sid = activeSmoothGroup; + faces.push_back(f); + + if (std::find(materials.begin(), materials.end(), matId) == materials.end()) { + materials.push_back(matId); + } + } + std::vector materials; + std::string name; + std::vector faces; + int32_t activeSmoothGroup; + bool smoothGroupsEnabled; +}; + +class ObjMeshLoader { +public: + friend class ObjGroup; + ObjMeshLoader() : _activeMatId(-1){ + + } + + std::string read_file(std::wstring path) + { + FILE* file = nullptr; + auto err = _wfopen_s(&file, path.c_str(), L"rb"); + + fseek(file, 0, SEEK_END); + auto file_size = ftell(file); + + std::string str; + str.resize(file_size); + fseek(file, 0, SEEK_SET); + + auto done = fread_s(&str[0], file_size, 1, file_size, file); + fclose(file); + return str; + } + std::vector Load(const std::wstring& path) { + std::vector result; + + /*if (!file1.good()) { + return result; + }*/ + + auto str = read_file(path); + + + std::stringstream buffer(str); + std::vector line_buffer; + line_buffer.resize(8192); + + + std::string previous_line; + std::string line; + //while (buffer.getline(&line_buffer[0], line_buffer.size())) { + while (std::getline(buffer, line)) { + + //std::string line(&line_buffer[0]); + if (line.size() < 3) { + continue; + } + switch(line[0]){ + case 'v': + switch (line[1]) { + case ' ': { + float3 v; + sscanf_s(&line[2], "%f%f%f", &v.x(), &v.y(), &v.z()); + _vertices.push_back(v); + break; + } + case 'n': { + float3 n; + sscanf_s(&line[2], "%f%f%f", &n.x(), &n.y(), &n.z()); + _normals.push_back(n); + break; + } + case 't': + float3 t; + sscanf_s(&line[2], "%f%f%f", &t.x(), &t.y(), &t.z()); + _texcoords.push_back(t); + break; + } + break; + case 'f': { + bool is_open = false; + size_t start = 2; + int slash_pos_0 = 0; + int slash_pos_1 = 0; + + if(line[line.size() - 1] == '\r') + { + line[line.size() - 1] = ' '; + }else + { + line += " "; + } + + std::vector fVertices; + for (size_t i = 2; i < line.size(); ++i) { + if (line[i] == ' ') { + if (is_open) { //finalize chunk + is_open = false; + ObjVertex v; + if (slash_pos_0 == -1) { + auto pos2 = (int)buffer.tellg(); + sscanf_s(&line[start], "%d", &v.vid); + v.tid = v.nid = -1; + } else if (slash_pos_1 == -1) { + sscanf_s(&line[start], "%d/%d", &v.vid, &v.tid); + v.nid = -1; + } else { + if (slash_pos_1 - slash_pos_0 == 1) { + sscanf_s(&line[start], "%d//%d", &v.vid, &v.nid); + v.tid = -1; + } else { + sscanf_s(&line[start], "%d/%d/%d", &v.vid, &v.tid, &v.nid); + } + } + fVertices.push_back(v); + } + } else { + if (!is_open) { + start = i; + slash_pos_0 = -1; + slash_pos_1 = -1; + is_open = true; + } else { + if (line[i] == '/') { + if (slash_pos_0 == -1) { + slash_pos_0 = i; + } else { + slash_pos_1 = i; + } + } + } + } + + + } + + //emit triangles (split if quads) + if (fVertices.size() == 3) { + _groups[_groups.size() - 1].AddFace(_activeMatId, fVertices[0], fVertices[1], fVertices[2]); + } else if (fVertices.size() == 4) { + _groups[_groups.size() - 1].AddFace(_activeMatId, fVertices[0], fVertices[1], fVertices[2]); + _groups[_groups.size() - 1].AddFace(_activeMatId, fVertices[0], fVertices[2], fVertices[3]); + } + break; + } + case 'g': { + auto name = line.substr(2); + _groups.push_back(ObjGroup(name)); + break; + } + case 's': + if (line.find("off") != std::string::npos) { + _groups[_groups.size() - 1].smoothGroupsEnabled = false; + } else { + sscanf_s(&line[2], "%d", &_groups[_groups.size() - 1].activeSmoothGroup); + } + break; + case 'm': { + std::stringstream ss(line); + std::string key, value; + ss >> key; + ss >> value; + _mtlLibName = value; + std::cout << "Found material library: " << value << std::endl; + break; + } + case 'u': { + std::stringstream ss(line); + std::string key, value; + ss >> key; + ss >> value; + SetActiveMaterial(value); + break; + } + } + + previous_line = line; + } + + + auto mtllib_path = obj_to_mtl_path(path); + + _mats = load_mtllib(mtllib_path); + + for (auto& group : _groups) { + result.push_back(UnpackGroup(group)); + } + return result; + } +private: + std::vector _mats; + std::wstring obj_to_mtl_path(const std::wstring& obj_path){ + std::filesystem::path src(obj_path); + auto dst = src.parent_path(); + return dst.append(_mtlLibName).wstring(); + } + + std::vector load_mtllib(const std::wstring& path){ + std::vector result; + + auto text = std::ifstream(path); + + std::string line; + auto default_shader = Shader::Create(L"Shaders/default.fx"); + + MaterialPtr active_material; + while(std::getline(text, line)) + { + if(line[0] == '#' || line.empty()){ + continue; + } + + std::string word; + std::stringstream ls(line); + ls >> word; + + if (word == "newmtl") { + std::string mat_name; + ls >> mat_name; + if(active_material != nullptr) + { + result.push_back(active_material); + } + active_material = Material::Create(default_shader, mat_name); + + } else { + if (active_material == nullptr) { + continue; + } else { + if(word == "Kd") + { + std::vector color; + float tmp = 0.0f; + while(ls >> tmp) + { + color.push_back(tmp); + } + + if(color.size() == 3) + { + active_material->GetParametersBlock().SetValue(Material::DiffuseColorName(), float4(color[0], color[1], color[2], 1.0f)); + } + } + } + } + } + + if (active_material != nullptr) { + result.push_back(active_material); + } + + return result; + + } + + typedef std::tuple VertexPair; + GameObjectPtr UnpackGroup(const ObjGroup& group) { + std::vector> facesTable; + facesTable.resize(_vertices.size()); + std::vector vertices; + std::map> submeshes; + + //EmitGeometry(group, vertices, submeshes); + EmitGeometrySimple(group, vertices, submeshes); + + auto mesh = Mesh::Create(); + mesh->SetSubmeshCount(group.materials.size()); + mesh->SetVertices(vertices); + + + + int id = 0; + for(auto& p : submeshes) + { + mesh->SetIndices(p.second, MeshTopology::TriangleList, id); + id++; + } + + auto obj = GameObject::create(); + obj->AddComponent()->SetMesh(mesh); + + + + for (size_t i = 0; i < group.materials.size(); ++i){ + auto mat_id = group.materials[i]; + + obj->GetComponent()->SetMaterial(_mats[mat_id], i); + } + + mesh->RecalculateBounds(); + return obj; + } + + /*MeshPtr BuildMesh(ObjGroup& group) { + std::vector vertices; + std::vector indices; + EmitGeometry(group, vertices, indices); + + auto mesh = Mesh::Create(); + mesh->SetSubmeshCount(group.materials.size()); + return mesh; + }*/ + + void EmitGeometry(const ObjGroup& group, std::vector& vertices, std::map>& submeshes) { + auto vComp = [](ObjVertex v1, ObjVertex v2) { + return (v1.vid == v2.vid) && (v1.tid == v2.tid) && (v1.nid && v2.nid); + }; + + std::vector tmpVertices; + + for (auto& f : group.faces) { + for (auto& v : f.vertices) { + int id = -1; + for (size_t i = 0; i < tmpVertices.size(); ++i) { + if (vComp(tmpVertices[i], v)) { + id = i; + break; + } + } + + if (id == -1) { + id = tmpVertices.size(); + tmpVertices.push_back(v); + Vertex vertex; + vertex.position = float4(_vertices[v.vid - 1], 1.0f); + vertex.normal = _normals[v.nid - 1]; + vertex.uv0 = _texcoords[v.tid - 1].xy(); + vertices.push_back(vertex); + } + + submeshes[f.mid].push_back(id); + } + } + } + + void EmitGeometrySimple(const ObjGroup& group, std::vector& vertices, std::map>& submeshes) { + int id = 0; + for (auto& f : group.faces) { + for (auto& v : f.vertices) { + Vertex vertex; + vertex.position = float4(_vertices[v.vid - 1], 1.0f); + vertex.normal = _normals[v.nid - 1]; + vertex.uv0 = _texcoords[v.tid - 1].xy(); + vertices.push_back(vertex); + submeshes[f.mid].push_back(id); + ++id; + } + } + } + + void SetActiveMaterial(const std::string& name) { + for (size_t i = 0; i < _materials.size(); ++i) { + if (_materials[i] == name) { + _activeMatId = i; + return; + } + } + _activeMatId = _materials.size(); + _materials.push_back(name); + } + int _activeMatId; + std::string _mtlLibName; + std::vector _vertices; + std::vector _normals; + std::vector _texcoords; + std::vector _materials; + std::vector _groups; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Object.cpp b/Src/RenderFramework/Object.cpp new file mode 100644 index 0000000..c46e685 --- /dev/null +++ b/Src/RenderFramework/Object.cpp @@ -0,0 +1,39 @@ +#include "Object.h" +#include "Archive.h" + +std::map> ObjectRegistry::_registry; + +std::atomic ObjectRegistry::_last_index = 0; + +Object::Object():_instance_id(-1){ + +} + +std::shared_ptr Object::create(){ + auto result = std::shared_ptr(new Object()); + result->Register(); + return result; +} + +Object::~Object(){ + ObjectRegistry::remove_object(_instance_id); +} + +void Object::Register(){ + _instance_id = ObjectRegistry::add_object(shared_from_this()); +} + +void Object::serialize(Archive& archive) { + archive << _name; +} + +ObjectRegistry::instance_id_t ObjectRegistry::add_object(std::shared_ptr object) { + auto result = _last_index++; + _registry[result] = object; + return result; +} + +void ObjectRegistry::remove_object(instance_id_t object) { + _registry.erase(object); +} + diff --git a/Src/RenderFramework/Object.h b/Src/RenderFramework/Object.h new file mode 100644 index 0000000..37ddadb --- /dev/null +++ b/Src/RenderFramework/Object.h @@ -0,0 +1,104 @@ +#ifndef Object_h__ +#define Object_h__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "Asset.h" + +class Object; +class OutputArchive; + +class ObjectRegistry { +public: + using instance_id_t = uint64_t; + friend class Object; +private: + static instance_id_t add_object(std::shared_ptr object); + static void remove_object(instance_id_t object); + static std::map> _registry; + static std::atomic _last_index; +}; + +class Archive; +class Object : public std::enable_shared_from_this{ +public: + using instance_id_t = ObjectRegistry::instance_id_t; + virtual void serialize(Archive& archive); + + virtual void construct() { + + } + + virtual std::wstring get_type_name() const{ + return L"Object"; + } + + std::shared_ptr as_object(){ + return shared_from_this(); + } + + template + static std::vector> FindObjectsOfType() { + std::vector> result; + auto& registry = ObjectRegistry::_registry; + for(auto& pair : registry){ + auto obj = pair.second.lock(); + auto targetObj = std::dynamic_pointer_cast(obj); + if(targetObj != nullptr){ + result.push_back(targetObj); + } + } + return result; + } + + static std::shared_ptr Find(const AssetFileLink& link) + { + auto& registry = ObjectRegistry::_registry; + for (auto& pair : registry) { + auto obj = pair.second.lock(); + if(obj != nullptr && obj->GetFileLink() == link) + { + return obj; + } + } + return nullptr; + } + + static std::shared_ptr create(); + virtual ~Object(); + + const std::wstring& get_name() const{ + return _name; + } + + void SetName(const std::wstring& name){ + _name = name; + } + + instance_id_t GetInstanceId() const{ + return _instance_id; + } + + const AssetFileLink& GetFileLink() const{ + return _fileLink; + } + void SetLink(const AssetFileLink& link){ + _fileLink = link; + } +protected: + void Register(); + Object(); + AssetFileLink _fileLink; + instance_id_t _instance_id; +private: + std::wstring _name; +}; + +#endif // Object_h__ diff --git a/Src/RenderFramework/ObjectsFactory.cpp b/Src/RenderFramework/ObjectsFactory.cpp new file mode 100644 index 0000000..8b9f47b --- /dev/null +++ b/Src/RenderFramework/ObjectsFactory.cpp @@ -0,0 +1,21 @@ +#include "ObjectsFactory.h" + + +void ObjectsFactory::register_factory(factory_function factory, const std::wstring& class_name) { + + _factory_functions[class_name] = factory; +} + +ObjectsFactory& ObjectsFactory::instance() +{ + static ObjectsFactory instance; + return instance; +} + +std::shared_ptr ObjectsFactory::create_object(const std::wstring& class_name) const { + try { + return _factory_functions.at(class_name)(); + } catch (...) { + return nullptr; + } +} \ No newline at end of file diff --git a/Src/RenderFramework/ObjectsFactory.h b/Src/RenderFramework/ObjectsFactory.h new file mode 100644 index 0000000..ed567a0 --- /dev/null +++ b/Src/RenderFramework/ObjectsFactory.h @@ -0,0 +1,58 @@ +#ifndef ComponentFactory_h__ +#define ComponentFactory_h__ + +#include "ForwardDeclarations.h" +#include +#include +#include "Object.h" + +class ObjectsFactory { +public: + typedef std::function()> factory_function; + typedef std::map factory_container; + + static ObjectsFactory& instance(); + void register_factory(factory_function factory, const std::wstring& class_name); + std::shared_ptr create_object(const std::wstring& class_name) const; + + template + std::shared_ptr create_object(){ + return std::dynamic_pointer_cast(create_object(T::type_name(), game_object)); + } +private: + factory_container _factory_functions; +}; + + +template +struct ObjectFactory { + typedef std::shared_ptr object_pointer_t; + ObjectFactory() { + ObjectsFactory::instance().register_factory(&factory_func, T::type_name()); + } + static std::shared_ptr factory_func() { + return std::static_pointer_cast(T::create()); + } +}; + + +#define LOBJECT(__type_name, __base_type) \ +class __type_name;\ +static ObjectFactory<__type_name> __type_name##_factory;\ +class __type_name : public __base_type {\ +public:\ +static std::wstring type_name() {\ +return L#__type_name;\ +}\ +std::wstring get_type_name() const override{\ + return L#__type_name;\ +}\ +static std::shared_ptr<__type_name> create() {\ + auto result = std::shared_ptr<__type_name>(new __type_name());\ + result->Register();\ + result->construct();\ + return result;\ +} + + +#endif // ComponentFactory_h__ diff --git a/Src/RenderFramework/OutputArchive.h b/Src/RenderFramework/OutputArchive.h new file mode 100644 index 0000000..0ee5b41 --- /dev/null +++ b/Src/RenderFramework/OutputArchive.h @@ -0,0 +1,53 @@ +#ifndef OutputArchive_h__ +#define OutputArchive_h__ + +#include "Archive.h" +#include "Object.h" +#include +#include +#include +#include + +class OutputArchive : public Archive { +public: + OutputArchive(std::shared_ptr stream) + :_stream(stream) { + // _stream = std::ofstream(path, std::ios::binary); + } + + virtual bool is_loading() const override { + return false; + } + + size_type get_offset() const override { + return _stream->tellp(); + } + + void set_offset(size_type offset) override { + _stream->seekp(offset, std::ios::beg); + } + + virtual void serialize(void* data, size_t size) override { + _stream->write(reinterpret_cast(data), size); + } + + virtual void flush() override { + if(_stream->good()){ + _stream->flush(); + } + } + + ~OutputArchive() { + flush(); + } + std::shared_ptr GetStream() + { + return _stream; + } +private: + std::shared_ptr _stream; + std::vector> _processed_objects; +}; + + +#endif // OutputArchive_h__ diff --git a/Src/RenderFramework/RenderOutput.h b/Src/RenderFramework/RenderOutput.h new file mode 100644 index 0000000..af4b828 --- /dev/null +++ b/Src/RenderFramework/RenderOutput.h @@ -0,0 +1,31 @@ +#pragma once + +#include +#include +#include "Renderer.h" +#include +#include + +class RenderOutput { +public: + + virtual ~RenderOutput() { + } + virtual uint32_t GetWidth() = 0; + virtual uint32_t GetHeight() = 0; + + //virtual CD3DX12_CPU_DESCRIPTOR_HANDLE GetRenderTargetDescriptor(uint32_t id) = 0; + //virtual CD3DX12_CPU_DESCRIPTOR_HANDLE GetDepthStencilDescriptor(uint32_t id) = 0; + + //virtual ID3D12ResourcePtr GetRenderTarget(uint32_t id) = 0; + //virtual ID3D12ResourcePtr GetDepthBuffer(uint32_t id) = 0; + + virtual void Present() = 0; + virtual void OnPreRender(RendererPtr renderer) = 0; + + virtual uint32_t GetCurrentBufferIndex() = 0; + virtual uint32_t GetBuffersCount() = 0; +protected: +}; + +typedef std::shared_ptr RenderOutputPtr; diff --git a/Src/RenderFramework/RenderTargetOutput.cpp b/Src/RenderFramework/RenderTargetOutput.cpp new file mode 100644 index 0000000..4c61f38 --- /dev/null +++ b/Src/RenderFramework/RenderTargetOutput.cpp @@ -0,0 +1,81 @@ +#include "RenderTargetOutput.h" +/* +std::shared_ptr RenderTargetOutput::Create(RendererPtr renderer) { + return std::shared_ptr(new RenderTargetOutput(renderer)); +} +RenderTargetOutput::RenderTargetOutput(RendererPtr renderer) + :_renderer(renderer) { + +} +uint32_t RenderTargetOutput::GetWidth() { + if (_rt == nullptr) { + return 0; + } + D3D11_TEXTURE2D_DESC desc; + _rt->GetDesc(&desc); + return desc.Width; +} +uint32_t RenderTargetOutput::GetHeight() { + if (_rt == nullptr) { + return 0; + } + D3D11_TEXTURE2D_DESC desc; + _rt->GetDesc(&desc); + return desc.Height; +} +ID3D11RenderTargetViewPtr RenderTargetOutput::GetRenderTargetView() { + return _rtView; +} +ID3D11DepthStencilViewPtr RenderTargetOutput::GetDepthStencilView() { + return _dsView; +} +void RenderTargetOutput::Present() { + +} +void RenderTargetOutput::OnPreRender(RendererPtr renderer) { + +} +void RenderTargetOutput::Resize(uint32_t width, uint32_t height) { + if (_rt != nullptr) { + D3D11_TEXTURE2D_DESC desc; + _rt->GetDesc(&desc); + if (desc.Width == width && desc.Height == height) { + return; + } + } + + _rt = nullptr; + _ds = nullptr; + _rtView = nullptr; + _dsView = nullptr; + + D3D11_TEXTURE2D_DESC desc = { 0 }; + desc.Width = width; + desc.Height = height; + desc.MipLevels = 1; + desc.ArraySize = 1; + desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + desc.SampleDesc.Count = 1; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + auto hr = _renderer->GetDevice()->CreateTexture2D(&desc, nullptr, &_rt); + hr = _renderer->GetDevice()->CreateRenderTargetView(_rt, nullptr, &_rtView); + + D3D11_TEXTURE2D_DESC descDepth; + descDepth.Width = width; + descDepth.Height = height; + descDepth.MipLevels = 1; + descDepth.ArraySize = 1; + descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; + descDepth.SampleDesc.Count = 1; + descDepth.SampleDesc.Quality = 0; + descDepth.Usage = D3D11_USAGE_DEFAULT; + descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL; + descDepth.CPUAccessFlags = 0; + descDepth.MiscFlags = 0; + hr = _renderer->GetDevice()->CreateTexture2D(&descDepth, NULL, &_ds); + hr = _renderer->GetDevice()->CreateDepthStencilView(_ds, nullptr, &_dsView); +}*/ \ No newline at end of file diff --git a/Src/RenderFramework/RenderTargetOutput.h b/Src/RenderFramework/RenderTargetOutput.h new file mode 100644 index 0000000..dcf8eef --- /dev/null +++ b/Src/RenderFramework/RenderTargetOutput.h @@ -0,0 +1,25 @@ +#pragma once + +#include "RenderOutput.h" +#include "Renderer.h" + + +/* +class RenderTargetOutput : public RenderOutput { +public: + static std::shared_ptr Create(RendererPtr renderer); + virtual uint32_t GetWidth() override; + virtual uint32_t GetHeight() override; + virtual ID3D11RenderTargetViewPtr GetRenderTargetView() override; + virtual ID3D11DepthStencilViewPtr GetDepthStencilView() override; + virtual void Present() override; + virtual void OnPreRender(RendererPtr renderer) override; + void Resize(uint32_t width, uint32_t height); +private: + RenderTargetOutput(RendererPtr renderer); + ID3D11DepthStencilViewPtr _dsView; + ID3D11RenderTargetViewPtr _rtView; + ID3D11Texture2DPtr _ds; + ID3D11Texture2DPtr _rt; + RendererPtr _renderer; +};*/ diff --git a/Src/RenderFramework/Renderer.cpp b/Src/RenderFramework/Renderer.cpp new file mode 100644 index 0000000..a6f1c2c --- /dev/null +++ b/Src/RenderFramework/Renderer.cpp @@ -0,0 +1,219 @@ +#include "Renderer.h" +#include +#ifdef WIN32 +#include +#endif + +bool Renderer::Init() { + _vulkanLibrary = std::make_shared(); + + auto layers = _vulkanLibrary->getSupportedLayers(); + + if (std::find_if(layers.begin(), layers.end(), [](VkLayerProperties& layer) { return std::string(layer.layerName) == "VK_LAYER_KHRONOS_validation"; }) == layers.end()) { + throw std::runtime_error("Validation layer not found"); + } + std::vector instanceLayers; + instanceLayers.push_back("VK_LAYER_KHRONOS_validation"); + + VulkanApplicationInfo appInfo("Test project", 1, "Test"); + + std::vector requiredExtensions; + requiredExtensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME); +#ifdef WIN32 + requiredExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME); +#endif + + _vulkanInstance = _vulkanLibrary->createInstance(appInfo, 0, instanceLayers, requiredExtensions); + + auto physicalDevices = _vulkanInstance->enumeratePhysicalDevices(); + auto physicalDevice = physicalDevices[0]; + + auto families = physicalDevice->getQueueFamilyProperties(); + + //Find queues + for (std::uint32_t i = 0; i < static_cast(families.size()); ++i) { + if (!_presentQueueFamilyIndex.has_value() && families[i].queueCount > 0 && physicalDevice->getPresentationSupport(i)) { + _presentQueueFamilyIndex = i; + std::cout << "Found present queue: " << i << std::endl; + } + + if (!_graphicsQueueFamilyIndex.has_value() && families[i].isGraphics() && families[i].queueCount > 0) { + std::cout << "Found render queue: " << i << std::endl; + _graphicsQueueFamilyIndex = i; + } + + if (_graphicsQueueFamilyIndex.has_value() && _presentQueueFamilyIndex.has_value()) { + break; + } + } + + if (!_graphicsQueueFamilyIndex.has_value()) { + throw std::runtime_error("Failed to find graphics queue family"); + } + if (!_presentQueueFamilyIndex.has_value()) { + throw std::runtime_error("Failed to find present queue family"); + } + + + std::vector queueDescriptions; + if (_graphicsQueueFamilyIndex.has_value()) { + queueDescriptions.push_back(VulkanQueueCreateInfo(_graphicsQueueFamilyIndex.value(), { 1.0f })); + } + if (_presentQueueFamilyIndex.has_value()) { + if (_graphicsQueueFamilyIndex.value() != _presentQueueFamilyIndex.value()) { + queueDescriptions.push_back(VulkanQueueCreateInfo(_presentQueueFamilyIndex.value(), { 1.0f })); + } + } + + auto deviceExtensions = physicalDevice->getExtensions(); + std::vector requiredDeviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }; + auto swapChainExt = std::find_if(deviceExtensions.begin(), deviceExtensions.end(), [&requiredDeviceExtensions](VkExtensionProperties ext) { return std::string(requiredDeviceExtensions[0]) == ext.extensionName; }); + if (swapChainExt == deviceExtensions.end()) { + throw std::runtime_error("Failed to find device with swap chain extension"); + } + + _logicalDevice = PVulkanLogicalDevice(new VulkanLogicalDevice(physicalDevice, requiredDeviceExtensions, {}, queueDescriptions)); + + + //PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p; + //_vulkanInstance->functions(). + + /* + + // Describe and create the command queue. + D3D12_COMMAND_QUEUE_DESC queueDesc = {}; + queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; + queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; + + device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&_directCommandQueue)); + device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&_directCommandAllocator)); + device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, _directCommandAllocator.Get(), nullptr, IID_PPV_ARGS(&_directCommandList)); + + + //create descriptor heaps + + constexpr size_t descriptorHeapsSize = 512; + + D3D12_DESCRIPTOR_HEAP_DESC srvHeapDesc = {}; + srvHeapDesc.NumDescriptors = descriptorHeapsSize; + srvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; + srvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; + hr = device->CreateDescriptorHeap(&srvHeapDesc, IID_PPV_ARGS(&_srvDescriptorsHeap)); + if (FAILED(hr)) + { + FatalError(L"Failed to create SRV descriptors heap"); + } + _srvDescriptorsHeap->SetName(L"SRV Heap"); + + _srvDescriptorAllocator = std::make_shared(_srvDescriptorsHeap); +*/ + return true; +} + +//std::shared_ptr Renderer::getSrvDescriptorsAllocator(){ +// return _srvDescriptorAllocator; +//} + +//ComPtr Renderer::BeginCommandList(){ +// auto HR = _directCommandAllocator->Reset(); +// HR = _directCommandList->Reset(_directCommandAllocator.Get(), nullptr); +// return _directCommandList; +//} + +void Renderer::EndCommandList(){ + //_directCommandList->Close(); + //ID3D12CommandList* ppCommandLists[] = { _directCommandList.Get()}; + //_directCommandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists); +} + +void Renderer::WaitCommandsQueue(){ + //ID3D12Fence* fence = nullptr; + //HRESULT hr = device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&fence)); + //if (hr) + // return; +// + //auto eventHandle = CreateEvent(NULL, FALSE, FALSE, NULL); +// + //_directCommandQueue->Signal(fence, 1); + //fence->SetEventOnCompletion(1, eventHandle); + //WaitForSingleObject(eventHandle, INFINITE); +// + //CloseHandle(eventHandle); + //fence->Release(); +} + +PVulkanLogicalDevice Renderer::GetLogicalDevice() { + return _logicalDevice; +} + +//std::vector Renderer::EnumOutputs() { +// IDXGIOutput1Ptr pOutput; +// std::vector vOutputs; +// int outputId = 0; +// +// IDXGIOutputPtr o; +// while (GetAdapter()->EnumOutputs(outputId, &o) != DXGI_ERROR_NOT_FOUND) { +// o->QueryInterface(IID_PPV_ARGS(&pOutput)); +// vOutputs.push_back(pOutput); +// pOutput = nullptr; +// o = nullptr; +// ++outputId; +// } +// return vOutputs; +//} + +// IDXGISwapChain1Ptr Renderer::CreateSwapChain(HWND window, bool windowed, uint32_t width, uint32_t height, uint32_t buffers_count, bool stereo) { +// DXGI_SWAP_CHAIN_DESC1 swapChainDesc = { 0 }; +// swapChainDesc.Width = width; +// swapChainDesc.Height = height; +// swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; +// swapChainDesc.Stereo = stereo; +// swapChainDesc.SampleDesc.Count = 1; +// swapChainDesc.SampleDesc.Quality = 0; +// swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; +// swapChainDesc.BufferCount = buffers_count; +// swapChainDesc.Scaling = DXGI_SCALING_STRETCH; +// swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; +// swapChainDesc.Flags = 0; +// swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; + +// /*DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreenDesc = { 0 }; +// fullscreenDesc.RefreshRate = {60 ,0}; +// fullscreenDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; +// fullscreenDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; +// fullscreenDesc.Windowed = windowed;*/ + +// IDXGISwapChain1Ptr result; +// auto hr = GetFactory()->CreateSwapChainForHwnd(_directCommandQueue.Get(), window, &swapChainDesc, nullptr, nullptr, &result); +// if (S_OK != hr){ +// FatalError(TEXT("Failed to create swap chain")); +// } +// return result; +// } + +//auto backBufferFormat = DXGI_FORMAT_B8G8R8A8_UNORM; + +//std::vector Renderer::GetDisplayModes(DXGI_FORMAT format, IDXGIOutput1Ptr output) { +// std::vector result; +// UINT numStereoModes = 0; +// DXGI_MODE_DESC1 modes[1024]; +// auto enumFlags = DXGI_ENUM_MODES_STEREO; +// +// output->GetDisplayModeList1(format, enumFlags, &numStereoModes, 0); +// output->GetDisplayModeList1(format, enumFlags, &numStereoModes, modes); +// +// for (UINT i = 0; i < numStereoModes; ++i) { +// result.push_back(modes[i]); +// } +// return result; +//} + +//std::vector Renderer::GetStereoModes(std::vector& modes) { +// std::vector result; +// for (auto& m : modes) { +// if (m.Stereo) { +// result.push_back(m); +// } +// } +// return result; +//} \ No newline at end of file diff --git a/Src/RenderFramework/Renderer.h b/Src/RenderFramework/Renderer.h new file mode 100644 index 0000000..996d2f2 --- /dev/null +++ b/Src/RenderFramework/Renderer.h @@ -0,0 +1,65 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include "FatalError.h" +#include +#include +#include +#include +#include +#include +#include + +using namespace Microsoft::WRL; + + +class Renderer { +public: + bool Init(); + + PVulkanLogicalDevice GetLogicalDevice(); + + //ComPtr GetAdapter() { + // return dxgiAdapter; + //} + //ComPtr GetFactory() { + // return dxgiFactory; + //} + + //ComPtr BeginCommandList(); + void EndCommandList(); + + //std::vector EnumOutputs(); + //IDXGISwapChain1Ptr CreateSwapChain(HWND window, bool windowed, uint32_t width, uint32_t height, uint32_t buffers_count, bool stereo); + //std::vector GetDisplayModes(DXGI_FORMAT format, IDXGIOutput1Ptr output); + //std::vector GetStereoModes(std::vector& modes); + void WaitCommandsQueue(); + + //std::shared_ptr getSrvDescriptorsAllocator(); +private: + std::shared_ptr _vulkanLibrary; + IntrusivePtr _vulkanInstance; + PVulkanLogicalDevice _logicalDevice; + + std::optional _graphicsQueueFamilyIndex; + std::optional _presentQueueFamilyIndex; + + //ComPtr dxgiInfoQueue; + //ID3D12DevicePtr device; + //IDXGIAdapter1Ptr dxgiAdapter; + //IDXGIFactory4Ptr dxgiFactory; +// + //ComPtr _directCommandQueue; + //ComPtr _directCommandList; + //ComPtr _directCommandAllocator; +// + //ComPtr _srvDescriptorsHeap; + //std::shared_ptr _srvDescriptorAllocator; +}; + +typedef std::shared_ptr RendererPtr; diff --git a/Src/RenderFramework/Scene.cpp b/Src/RenderFramework/Scene.cpp new file mode 100644 index 0000000..5412bfd --- /dev/null +++ b/Src/RenderFramework/Scene.cpp @@ -0,0 +1,14 @@ +#include "Scene.h" +#include "GameObject.h" + +void Scene::tick(float deltaTime) { + for (auto go : objects) { + go->tick(deltaTime); + } +} +void Scene::SetName(const std::string& name) { + _name = name; +} +std::string Scene::GetName() { + return _name; +} \ No newline at end of file diff --git a/Src/RenderFramework/Scene.h b/Src/RenderFramework/Scene.h new file mode 100644 index 0000000..2c78de1 --- /dev/null +++ b/Src/RenderFramework/Scene.h @@ -0,0 +1,26 @@ +#ifndef Scene_h__ +#define Scene_h__ + +#include + +#include "ForwardDeclarations.h" +#include +#include "Gizmos.h" + +class Scene { +public: + Scene() { + _gizmos.Init(); + } + std::vector objects; + void tick(float deltaTime); + void SetName(const std::string& name); + std::string GetName(); + Gizmos& GetGizmos() { + return _gizmos; + } +private: + Gizmos _gizmos; + std::string _name; +}; +#endif // Scene_h__ diff --git a/Src/RenderFramework/SceneRenderer.cpp b/Src/RenderFramework/SceneRenderer.cpp new file mode 100644 index 0000000..b155496 --- /dev/null +++ b/Src/RenderFramework/SceneRenderer.cpp @@ -0,0 +1,308 @@ +#include "SceneRenderer.h" +#include "GameObject.h" +#include "Transform.h" +#include "Texture.h" + +SceneRenderer::SceneRenderer() +{ + auto renderer = LEngine::Instance()->GetRenderer(); + auto device = renderer->GetLogicalDevice(); + + //create samplers heap + //D3D12_DESCRIPTOR_HEAP_DESC samplers_heap_desc; + //samplers_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; + //samplers_heap_desc.NodeMask = 0; + //samplers_heap_desc.NumDescriptors = 1; + //samplers_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER; + // HR_ASSERT(device->CreateDescriptorHeap(&samplers_heap_desc, IID_PPV_ARGS(&samplers_heap))); + //samplers_heap->SetName(L"Samplers heap"); + + //create texture sampler + /*D3D12_SAMPLER_DESC sampler_desc = {}; + sampler_desc.Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR; + sampler_desc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP; + sampler_desc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP; + sampler_desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; + sampler_desc.MinLOD = 0; + sampler_desc.MaxLOD = D3D12_FLOAT32_MAX; + sampler_desc.MipLODBias = 0.0f; + sampler_desc.MaxAnisotropy = 1; + sampler_desc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;*/ + + // renderer->GetDevice()->CreateSampler(&sampler_desc, samplers_heap->GetCPUDescriptorHandleForHeapStart()); +} + +void SceneRenderer::RenderScene(RendererPtr renderer, ScenePtr scene, CameraPtr camera, std::shared_ptr renderScreen) { + camera->aspect = (float)renderScreen->GetWidth() / (float)renderScreen->GetHeight(); + renderScreen->OnPreRender(renderer); + + D3D12_VIEWPORT viewport = {}; + viewport.TopLeftX = 0; + viewport.TopLeftY = 0; + viewport.Width = (float)renderScreen->GetWidth(); + viewport.Height = (float)renderScreen->GetHeight(); + viewport.MinDepth = 0; + viewport.MaxDepth = 1; + + + D3D12_RECT scissorRect = {}; + scissorRect.left = 0; + scissorRect.top = 0; + scissorRect.right = renderScreen->GetWidth(); + scissorRect.bottom = renderScreen->GetHeight(); + + // auto commandList = renderer->BeginCommandList(); + // auto rt = renderScreen->GetRenderTarget(renderScreen->GetCurrentBufferIndex()); + // commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(rt.Get(), D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET)); + // auto rtvHandle = renderScreen->GetRenderTargetDescriptor(renderScreen->GetCurrentBufferIndex()); + // auto dsvHandle = renderScreen->GetDepthStencilDescriptor(renderScreen->GetCurrentBufferIndex()); + // commandList->OMSetRenderTargets(1, &rtvHandle, FALSE, &dsvHandle); +// + // const float clearColor[] = { 0.1f, 0.1f, 0.14f, 1.0f }; + // commandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr); + // commandList->ClearDepthStencilView(dsvHandle, D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, 1.0f, 0, 0, nullptr); + + //renderer->EndCommandList(); +// renderer->WaitCommandsQueue(); + + // commandList->RSSetViewports(1, &viewport); + // commandList->RSSetScissorRects(1, &scissorRect); + + std::vector> signatures; + std::vector> pso; + + + //draw all objects + for (auto obj : scene->objects) { + auto mr = obj->GetComponent(); + if (mr != nullptr) { + auto mesh = mr->GetMesh(); + if (mesh != nullptr) { + for (uint32_t i = 0; i < mesh->GetSubmeshCount(); ++i) { + auto mat = mr->GetMaterials()[i]; + auto submesh = mesh->GetSubmeshes()[i]; + if (mat == nullptr || submesh == nullptr) { + continue; + } + auto& params = mat->GetParametersBlock(); + + //params.SetShaderResource() + + //set system variables + auto tf = obj->transform->GetGlobalTransform(); + auto view = camera->worldToCameraMatrix(); + auto proj = camera->projectionMatrix(); + params.SetValue("mWorld", transpose(tf)); + params.SetValue("mView", transpose(view)); + params.SetValue("mProjection", transpose(proj)); + + auto camPos = camera->transform()->GetGlobalPosition(); + params.SetValue("cameraWorldPos", float4(camPos.x(), camPos.y(), camPos.z(), 0.0f)); + + mat->Apply(); + + + //create single element ranges for constant buffers + std::vector root_parameters; + + auto compiled_params = mat->GetCompiledParameters(ShaderType::Vs); + + for(auto p : compiled_params.buffers) + { + D3D12_ROOT_DESCRIPTOR rootCBVDescriptor; + rootCBVDescriptor.RegisterSpace = 0; + rootCBVDescriptor.ShaderRegister = p.bindPoint; + + D3D12_ROOT_PARAMETER root_param = {}; + root_param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; + root_param.Descriptor = rootCBVDescriptor; + + root_parameters.push_back(root_param); + } + + + size_t srvParamOffset = root_parameters.size(); + size_t srvParamCount = 0; + + // auto srvHeapAllocator = renderer->getSrvDescriptorsAllocator(); + // auto srvHeap = srvHeapAllocator->getHeap(); + + std::vector srvRanges[2]; + //size_t srvParamCount = + //VS + PS + for(int id = 0; id < 2; ++id){ + auto shader_params = mat->GetCompiledParameters((ShaderType)id); + + for(auto r : shader_params.resources){ + if(r.type == D3D_SIT_TEXTURE) + { + auto param = mat->GetParametersBlock().GetParameterByName(r.name); + auto texParam = std::static_pointer_cast(param); + auto tex = texParam == nullptr ? nullptr : texParam->value; + + D3D12_DESCRIPTOR_RANGE range{}; + range.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; + range.RegisterSpace = 0; + range.NumDescriptors = 1; + range.BaseShaderRegister = r.bindPoint; + // range.OffsetInDescriptorsFromTableStart = srvHeapAllocator->getDescriptorId(tex->srvDescriptor); + srvRanges[id].push_back(range); + } + } + } + + //for each shader => create root table parameter + for(size_t s = 0; s < 2; ++s) + { + auto& ranges = srvRanges[s]; + if(!ranges.empty()) + { + D3D12_ROOT_DESCRIPTOR_TABLE srvTable; + srvTable.NumDescriptorRanges = ranges.size(); + srvTable.pDescriptorRanges = &ranges[0]; + + D3D12_ROOT_PARAMETER srvParameter; + srvParameter.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; + srvParameter.ShaderVisibility = ((ShaderType)s == ShaderType::Vs) ? D3D12_SHADER_VISIBILITY_VERTEX : D3D12_SHADER_VISIBILITY_PIXEL; + srvParameter.DescriptorTable = srvTable; + root_parameters.push_back(srvParameter); + + srvParamCount++; + } + } + + + // create a static sampler + D3D12_STATIC_SAMPLER_DESC sampler = {}; + sampler.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT; + sampler.AddressU = D3D12_TEXTURE_ADDRESS_MODE_BORDER; + sampler.AddressV = D3D12_TEXTURE_ADDRESS_MODE_BORDER; + sampler.AddressW = D3D12_TEXTURE_ADDRESS_MODE_BORDER; + sampler.MipLODBias = 0; + sampler.MaxAnisotropy = 0; + sampler.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; + sampler.BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK; + sampler.MinLOD = 0.0f; + sampler.MaxLOD = D3D12_FLOAT32_MAX; + sampler.ShaderRegister = 0; + sampler.RegisterSpace = 0; + sampler.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; + + + //create root signature + // CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc; + // rootSignatureDesc.Init(root_parameters.size(), // we have 1 root parameter + // &root_parameters[0], // a pointer to the beginning of our root parameters array + // 1, + // &sampler, + // D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | // we can deny shader stages here for better performance + // D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS | + // D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS | + // D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS); + + + ComPtr signature; + ComPtr signatureErrors; + // auto hr = D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &signatureErrors); + // if (FAILED(hr)) { + // FatalError(L"Failed to serialize root signature"); + // } + + ComPtr rootSignature; + // hr = renderer->GetDevice()->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&rootSignature)); + // if (FAILED(hr)) { + // FatalError(L"Failed to create root signature"); + // } + + signatures.push_back(rootSignature); + + + //create PSO + DXGI_SAMPLE_DESC sampleDesc = {}; + sampleDesc.Count = 1; + + D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {}; + psoDesc.pRootSignature = rootSignature.Get(); + psoDesc.InputLayout = mr->GetInputLayout(); + psoDesc.VS = mat->GetShader()->GetShader(ShaderType::Vs)->get_bytecode(); + psoDesc.PS = mat->GetShader()->GetShader(ShaderType::Ps)->get_bytecode(); + psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; + psoDesc.RTVFormats[0] = DXGI_FORMAT_B8G8R8A8_UNORM; + psoDesc.SampleDesc = sampleDesc; + psoDesc.SampleMask = 0xffffffff; + // psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); + // psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); + // psoDesc.NumRenderTargets = 1; + // psoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT); + // psoDesc.DSVFormat = DXGI_FORMAT_D24_UNORM_S8_UINT; + + auto device = renderer->GetLogicalDevice(); + + + // if (FAILED(hr)) { + // FatalError(L"Failed to create PSO"); + // } + + ComPtr pipelineStateObject; + // hr = device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&pipelineStateObject)); + pipelineStateObject->SetName(L"PSO"); + + + pso.push_back(pipelineStateObject); + + + //commandList = renderer->BeginCommandList(); + + // commandList->SetPipelineState(pipelineStateObject.Get()); + + // commandList->SetGraphicsRootSignature(rootSignature.Get()); + + // commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + // auto vbView = mesh->GetVertexBufferView(); + + // commandList->IASetVertexBuffers(0, 1, &vbView); + + // auto ibView = submesh->GetIndexBufferView(); + // commandList->IASetIndexBuffer(&ibView); + + //commandList->SetGraphicsRootShaderResourceView() + + + // ID3D12DescriptorHeap* descriptorHeaps[] = { srvHeap.Get() }; + // commandList->SetDescriptorHeaps(_countof(descriptorHeaps), descriptorHeaps); + + + // for (size_t p = srvParamOffset; p < srvParamOffset + srvParamCount; ++p) { + // commandList->SetGraphicsRootDescriptorTable(p, srvHeap->GetGPUDescriptorHandleForHeapStart()); + // } + + // //apply constant buffers + // for (size_t k = 0; k < compiled_params.buffers.size(); ++k) { + // commandList->SetGraphicsRootConstantBufferView(k, compiled_params.buffers[k].buffer->GetGPUVirtualAddress()); + // } + + + // commandList->DrawIndexedInstanced(submesh->GetIndicesCount(), 1, 0, 0, 0); + + //renderer->EndCommandList(); + //renderer->WaitCommandsQueue(); + } + } + } + } + + //commandList = renderer->BeginCommandList(); + // commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(rt.Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT)); + renderer->EndCommandList(); + renderer->WaitCommandsQueue(); + + + + renderScreen->Present(); + //signatures.clear(); + //renderer->reportLiveObjects(); + + scene->GetGizmos().PrepareRender(); + scene->GetGizmos().DrawAll(camera); + scene->GetGizmos().Clear(); +} \ No newline at end of file diff --git a/Src/RenderFramework/SceneRenderer.h b/Src/RenderFramework/SceneRenderer.h new file mode 100644 index 0000000..76a7598 --- /dev/null +++ b/Src/RenderFramework/SceneRenderer.h @@ -0,0 +1,20 @@ +#pragma once +#include "LEngine.h" +#include "Mesh.h" +#include "MeshGenerator.h" +#include "Scene.h" +#include "Renderer.h" +#include "Camera.h" +#include "FatalError.h" +#include "MeshRenderer.h" + +#pragma comment(lib, "d3d11.lib") + +class SceneRenderer { +public: + SceneRenderer(); + void RenderScene(RendererPtr renderer, ScenePtr scene, CameraPtr camera, std::shared_ptr renderScreen); +private: + ComPtr samplers_heap; +}; + diff --git a/Src/RenderFramework/Shader.cpp b/Src/RenderFramework/Shader.cpp new file mode 100644 index 0000000..9bb03a2 --- /dev/null +++ b/Src/RenderFramework/Shader.cpp @@ -0,0 +1,240 @@ +#include "Shader.h" +#include +#include +#include "File.h" +#include "LEngine.h" +#include "AssetManager.h" +#include "ShaderInclude.h" +#include +#include +#include +#include + +#pragma comment(lib, "D3dcompiler.lib") + +static TBuiltInResource getShaderResources() { + TBuiltInResource resources = {}; + resources.maxLights = 32; + resources.maxClipPlanes = 6; + resources.maxTextureUnits = 32; + resources.maxTextureCoords = 32; + resources.maxVertexAttribs = 64; + resources.maxVertexUniformComponents = 4096; + resources.maxVaryingFloats = 64; + resources.maxVertexTextureImageUnits = 32; + resources.maxCombinedTextureImageUnits = 80; + resources.maxTextureImageUnits = 32; + resources.maxFragmentUniformComponents = 4096; + resources.maxDrawBuffers = 32; + resources.maxVertexUniformVectors = 128; + resources.maxVaryingVectors = 8; + resources.maxFragmentUniformVectors = 16; + resources.maxVertexOutputVectors = 16; + resources.maxFragmentInputVectors = 15; + resources.minProgramTexelOffset = -8; + resources.maxProgramTexelOffset = 7; + resources.maxClipDistances = 8; + resources.maxComputeWorkGroupCountX = 65535; + resources.maxComputeWorkGroupCountY = 65535; + resources.maxComputeWorkGroupCountZ = 65535; + resources.maxComputeWorkGroupSizeX = 1024; + resources.maxComputeWorkGroupSizeY = 1024; + resources.maxComputeWorkGroupSizeZ = 64; + resources.maxComputeUniformComponents = 1024; + resources.maxComputeTextureImageUnits = 16; + resources.maxComputeImageUniforms = 8; + resources.maxComputeAtomicCounters = 8; + resources.maxComputeAtomicCounterBuffers = 1; + resources.maxVaryingComponents = 60; + resources.maxVertexOutputComponents = 64; + resources.maxGeometryInputComponents = 64; + resources.maxGeometryOutputComponents = 128; + resources.maxFragmentInputComponents = 128; + resources.maxImageUnits = 8; + resources.maxCombinedImageUnitsAndFragmentOutputs = 8; + resources.maxCombinedShaderOutputResources = 8; + resources.maxImageSamples = 0; + resources.maxVertexImageUniforms = 0; + resources.maxTessControlImageUniforms = 0; + resources.maxTessEvaluationImageUniforms = 0; + resources.maxGeometryImageUniforms = 0; + resources.maxFragmentImageUniforms = 8; + resources.maxCombinedImageUniforms = 8; + resources.maxGeometryTextureImageUnits = 16; + resources.maxGeometryOutputVertices = 256; + resources.maxGeometryTotalOutputComponents = 1024; + resources.maxGeometryUniformComponents = 1024; + resources.maxGeometryVaryingComponents = 64; + resources.maxTessControlInputComponents = 128; + resources.maxTessControlOutputComponents = 128; + resources.maxTessControlTextureImageUnits = 16; + resources.maxTessControlUniformComponents = 1024; + resources.maxTessControlTotalOutputComponents = 4096; + resources.maxTessEvaluationInputComponents = 128; + resources.maxTessEvaluationOutputComponents = 128; + resources.maxTessEvaluationTextureImageUnits = 16; + resources.maxTessEvaluationUniformComponents = 1024; + resources.maxTessPatchComponents = 120; + resources.maxPatchVertices = 32; + resources.maxTessGenLevel = 64; + resources.maxViewports = 16; + resources.maxVertexAtomicCounters = 0; + resources.maxTessControlAtomicCounters = 0; + resources.maxTessEvaluationAtomicCounters = 0; + resources.maxGeometryAtomicCounters = 0; + resources.maxFragmentAtomicCounters = 8; + resources.maxCombinedAtomicCounters = 8; + resources.maxAtomicCounterBindings = 1; + resources.maxVertexAtomicCounterBuffers = 0; + resources.maxTessControlAtomicCounterBuffers = 0; + resources.maxTessEvaluationAtomicCounterBuffers = 0; + resources.maxGeometryAtomicCounterBuffers = 0; + resources.maxFragmentAtomicCounterBuffers = 1; + resources.maxCombinedAtomicCounterBuffers = 1; + resources.maxAtomicCounterBufferSize = 16384; + resources.maxTransformFeedbackBuffers = 4; + resources.maxTransformFeedbackInterleavedComponents = 64; + resources.maxCullDistances = 8; + resources.maxCombinedClipAndCullDistances = 8; + resources.maxSamples = 4; + resources.limits.nonInductiveForLoops = true; + resources.limits.whileLoops = true; + resources.limits.doWhileLoops = true; + resources.limits.generalUniformIndexing = true; + resources.limits.generalAttributeMatrixVectorIndexing = true; + resources.limits.generalVaryingIndexing = true; + resources.limits.generalSamplerIndexing = true; + resources.limits.generalVariableIndexing = true; + resources.limits.generalConstantMatrixVectorIndexing = true; + return resources; +} + + + + +static EShLanguage getShaderLanguage(ShaderType stage) { + switch(stage){ + case ShaderType::Vs: + return EShLanguage::EShLangVertex; + case ShaderType::Ps: + return EShLanguage::EShLangFragment; + default: + throw std::runtime_error("Not yet implemented"); + } +} + + +void* Shader::CompileSHader(const std::filesystem::path& filePath, ShaderType stage) { + auto filePathString = filePath.string(); + + + std::string shaderCode; + FileReadAllText(filePath.wstring(), shaderCode); + + auto language = getShaderLanguage(stage); + glslang::TProgram program; + glslang::TShader shader(language); + + const char* moduleSource = shaderCode.c_str(); + + const char* moduleName = filePathString.c_str(); + shader.setStringsWithLengthsAndNames(&moduleSource, nullptr, &moduleName, 1); + + shader.setEnvInput(glslang::EShSourceGlsl, language, glslang::EShClientVulkan, 110); + auto clientVersion = glslang::EShTargetVulkan_1_1; + shader.setEnvClient(glslang::EShClientVulkan, clientVersion); + shader.setEnvTarget(glslang::EShTargetSpv, glslang::EShTargetSpv_1_0); + + ShaderInclude includer; + + + auto resources = getShaderResources(); + + std::string processedShader; + auto messages = static_cast(EShMsgSpvRules | EShMsgVulkanRules | EShMsgDefault | EShMsgDebugInfo); + if (!shader.preprocess(&resources, clientVersion, ENoProfile, false, false, messages, &processedShader, includer)) { + std::cout << "Shader preprocess failed" << std::endl; + std::cout << shader.getInfoLog() << std::endl; + std::cout << shader.getInfoDebugLog() << std::endl; + throw std::runtime_error("Shader preprocess failed"); + } + + if (!shader.parse(&resources, clientVersion, true, messages, includer)) { + std::cout << "Shader parse failed" << std::endl; + std::cout << shader.getInfoLog() << std::endl; + std::cout << shader.getInfoDebugLog() << std::endl; + throw std::runtime_error("Shader parse failed"); + } + + program.addShader(&shader); + + if (!program.link(messages) || !program.mapIO()) { + throw std::runtime_error("Shader link failed"); + } + + program.buildReflection(); + + program.dumpReflection(); + + + glslang::SpvOptions spvOptions; + //DEBUG + //spvOptions.generateDebugInfo = true; + //spvOptions.disableOptimizer = true; + //spvOptions.optimizeSize = false; + + spvOptions.generateDebugInfo = false; + spvOptions.disableOptimizer = false; + spvOptions.optimizeSize = true; + + spv::SpvBuildLogger logger; + std::vector spirv; + GlslangToSpv(*program.getIntermediate(static_cast(language)), spirv, &logger, &spvOptions); + + + //program.get + + std::cout << "SPIR-V generation messages: " << logger.getAllMessages() << std::endl; + + return nullptr; +} + +Shader::Shader(ComPtr dev) :device(dev) { + +} + +ShaderPtr Shader::Create() { + return std::shared_ptr(nullptr); +} + +ShaderPtr Shader::Create(const std::filesystem::path& filePath) { + auto shader = Create(); + shader->FromFile(AssetManager::Instance()->GetFullAssetPath(filePath)); + return shader; +} + +void Shader::FromFile(const std::filesystem::path& shaderFilePath) { + + CompileSHader(shaderFilePath, ShaderType::Vs); + //auto vsBlob = CompileSHader(shaderFilePath, "main_vs", "vs_5_0"); + //if(vsBlob != nullptr) { + // ShaderDataPtr shader(new ShaderData()); + // shader->blob = vsBlob; + // shaders[(int)ShaderType::Vs] = shader; + //} + // + //auto psBlob = CompileSHader(shaderFilePath, "main_ps", "ps_5_0"); + //if(psBlob != nullptr) { + // ShaderDataPtr shader(new ShaderData()); + // shader->blob = psBlob; + // shaders[(int)ShaderType::Ps] = shader; + //} +} + +ShaderDataPtr Shader::GetShader(ShaderType type) { + return shaders[(uint32_t)type]; +} + +ComPtr Shader::GetDevice() { + return device; +} \ No newline at end of file diff --git a/Src/RenderFramework/Shader.h b/Src/RenderFramework/Shader.h new file mode 100644 index 0000000..816246b --- /dev/null +++ b/Src/RenderFramework/Shader.h @@ -0,0 +1,54 @@ +#pragma once + +#include +#include +#include +#include "ForwardDeclarations.h" +#include +#include +#include +#include + +using namespace Microsoft::WRL; + +class ShaderData { +public: + ComPtr blob; + + D3D12_SHADER_BYTECODE get_bytecode() { + D3D12_SHADER_BYTECODE bytecode = {}; + bytecode.BytecodeLength = blob->GetBufferSize(); + bytecode.pShaderBytecode = blob->GetBufferPointer(); + return bytecode; + } +}; + +typedef std::shared_ptr ShaderDataPtr; + +enum class ShaderType { + Vs, + Ps, + Gs, + Hull, + Domain, + Count +}; + +class Shader { +public: + std::wstring class_name() const { + return L"Shader"; + + + } + static ShaderPtr Create(); + static ShaderPtr Create(const std::filesystem::path& filePath); + void FromFile(const std::filesystem::path& shaderFilePath); + ShaderDataPtr GetShader(ShaderType type); + ComPtr GetDevice(); +private: + Shader(ComPtr dev); + ShaderDataPtr shaders[(uint32_t)ShaderType::Count]; + ComPtr device; + void* CompileSHader(const std::filesystem::path& filename, ShaderType stage); +}; diff --git a/Src/RenderFramework/ShaderInclude.h b/Src/RenderFramework/ShaderInclude.h new file mode 100644 index 0000000..766ff2b --- /dev/null +++ b/Src/RenderFramework/ShaderInclude.h @@ -0,0 +1,66 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include "File.h" +#include +#include +#include + +#include +#include + + +class ShaderInclude : public glslang::TShader::Includer { +public: + //ShaderInclude(std::wstring localDirectory){ + // _localPathStack.push(localDirectory); + //} + + + + struct IncludeContext { + std::filesystem::path path; + std::vector data; + }; + + IncludeResult *includeLocal(const char *headerName, const char *includerName, size_t inclusionDepth) override { + std::filesystem::path includerPath(includerName); + auto includerDirectory = includerPath.parent_path(); + auto fullIncludePath = includerDirectory / headerName; + + IncludeContext* context = new IncludeContext(); + FileReadAllBytes(fullIncludePath.string(), context->data); + + IncludeResult* result = new IncludeResult(fullIncludePath.string(), context->data.data(), context->data.size(), context); + _files.push(result); + return result; + } + + + IncludeResult* includeSystem(const char* /*headerName*/, const char* /*includerName*/, size_t /*inclusionDepth*/) override { + throw std::runtime_error("Not implemented"); + return nullptr; + } + + void releaseInclude(IncludeResult* inc) override { + auto* context = reinterpret_cast(inc->userData); + if (context != nullptr) { + delete context; + } + + if (_files.top() == inc) { + _files.pop(); + delete inc; + } + else { + throw std::runtime_error("Something went wrong"); + } + } +private: + std::stack _files; +}; diff --git a/Src/RenderFramework/ShaderParametersBlock.h b/Src/RenderFramework/ShaderParametersBlock.h new file mode 100644 index 0000000..d3f866a --- /dev/null +++ b/Src/RenderFramework/ShaderParametersBlock.h @@ -0,0 +1,156 @@ +#pragma once + +#include "Shader.h" +#include +#include +#include +#include "ForwardDeclarations.h" + +class ShaderBufferVariable { +public: + std::string name; + uint32_t offset; + uint32_t size; + + ShaderBufferVariable() { + + } + + ShaderBufferVariable(const std::string& _name, uint32_t _offset, uint32_t _size) + :name(_name), size(_size), offset(_offset){ + + } +}; + +class ShaderResourceVariable { +public: + std::string name; + uint32_t bindPoint; + D3D_SHADER_INPUT_TYPE type; +}; + +class ShaderBufferContext { +public: + //ID3D12ResourcePtr buffer; + size_t size; + std::vector variables; + std::string name; + uint32_t bindPoint; + D3D_SHADER_INPUT_TYPE type; +}; + +class ShaderParametersContext { +public: + void Clear() { + buffers.clear(); + resources.clear(); + } + std::vector buffers; + std::vector resources; +}; + +class ShaderParameter { +public: + virtual ~ShaderParameter() + { + } + + ShaderParameter(const std::string& _name) :name(_name) { + + } + virtual void* GetPointer() = 0; + std::string name; +}; + +typedef std::shared_ptr ShaderParameterPtr; + +template +class ShaderValueParameter : public ShaderParameter { +public: + ShaderValueParameter(const std::string& _name) :ShaderParameter(_name) + { + + } + void* GetPointer() override { + return &value; + } + T value; +}; + +class ShaderResourceParameter : public ShaderParameter { +public: + ShaderResourceParameter(const std::string& _name) :ShaderParameter(_name) { + + } + // ShaderResourceParameter(const std::string& _name, ID3D11ShaderResourceViewPtr view) : value(view), ShaderParameter(_name) { + // name = _name; + // } + //ID3D11ShaderResourceViewPtr value; + void* GetPointer() override { + return nullptr; + } +}; + +class ShaderTextureParameter : public ShaderParameter { +public: + ShaderTextureParameter(const std::string& _name) :ShaderParameter(_name) { + + } + ShaderTextureParameter(const std::string& _name, TexturePtr view) : ShaderParameter(_name), value(view){ + name = _name; + } + TexturePtr value; + void* GetPointer() override { + return nullptr; + } +}; + +typedef std::shared_ptr ShaderResourceParameterPtr; +typedef std::shared_ptr ShaderTextureParameterPtr; + +class ShaderParametersBlock { +public: + void SetTexture(const std::string& name, TexturePtr texture) { + /*ID3D11ResourcePtr resourcePtr; + + D3D11_TEXTURE2D_DESC desc; + texture->GetDesc(&desc); + texture.QueryInterface(&resourcePtr); + SetShaderResource(name, resourcePtr);*/ + + ShaderTextureParameterPtr parameter(new ShaderTextureParameter(name, texture)); + for (auto it = parameters.begin(); it != parameters.end(); ++it) { + if ((*it)->name == name) { + *it = parameter; + return; + } + } + parameters.push_back(parameter); + + } + + template + void SetValue(const std::string& name, const T& value) { + std::shared_ptr> param(new ShaderValueParameter(name)); + param->value = value; + for (auto it = parameters.begin(); it != parameters.end(); ++it) { + if ((*it)->name == name) { + *it = param; + return; + } + } + parameters.push_back(param); + } + + ShaderParameterPtr GetParameterByName(const std::string& name) { + for (auto p : parameters) { + if (p->name == name) { + return p; + } + } + return nullptr; + } +private: + std::vector parameters; +}; + diff --git a/Src/RenderFramework/Submesh.h b/Src/RenderFramework/Submesh.h new file mode 100644 index 0000000..f040375 --- /dev/null +++ b/Src/RenderFramework/Submesh.h @@ -0,0 +1,114 @@ +#pragma once + +#include +#include "LEngine.h" +#include + +enum class MeshTopology { + TriangleList, + TriangleStrip, + LineList, + LineStrip +}; + +class Submesh { +public: + typedef uint32_t index_count_t; + typedef uint32_t index_t; + typedef std::vector index_array_t; + + Submesh() + :_indexCount(0) + { + + } + //ID3D12ResourcePtr GetIndexBuffer() const{ + // return _indexBuffer; + //} + + MeshTopology GetTopology() const{ + return _topology; + } + + D3D12_INDEX_BUFFER_VIEW GetIndexBufferView() + { + return _indexBufferView; + } + + void Set(index_array_t indices, MeshTopology topology) { + // _indexCount = indices.size(); + // _topology = topology; + //_indexBuffer = nullptr; + + // if (_indexCount == 0) { + // return; + // } + + // D3D11_BUFFER_DESC desc = { 0 }; + // D3D11_SUBRESOURCE_DATA data = { 0 }; + + //index buffer + // desc.Usage = D3D11_USAGE_DEFAULT; + // desc.ByteWidth = sizeof(indices[0]) * indices.size(); + // desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + // desc.CPUAccessFlags = 0; + // desc.MiscFlags = 0; + + // data.pSysMem = &indices[0]; + // data.SysMemPitch = 0; + // data.SysMemSlicePitch = 0; + + // auto renderer = LEngine::Instance()->GetRenderer(); + // auto device = renderer->GetDevice(); + // auto cmdList = renderer->BeginCommandList(); + + //create temporal upload resource + // ComPtr uploadBuffer; + // device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), + // D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES, + // &CD3DX12_RESOURCE_DESC::Buffer(desc.ByteWidth), + // D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&uploadBuffer)); + + + //upload data to temporal resource + // void* p; + // uploadBuffer->Map(0, nullptr, &p); + // memcpy(p, &indices[0], desc.ByteWidth); + // uploadBuffer->Unmap(0, nullptr); + + // device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), + // D3D12_HEAP_FLAG_NONE, + // &CD3DX12_RESOURCE_DESC::Buffer(desc.ByteWidth), + // D3D12_RESOURCE_STATE_COPY_DEST, + // nullptr, + // IID_PPV_ARGS(&_indexBuffer)); + + + // _indexBufferView.BufferLocation = _indexBuffer->GetGPUVirtualAddress(); + // _indexBufferView.SizeInBytes = desc.ByteWidth; + // _indexBufferView.Format = DXGI_FORMAT_R32_UINT; + + + // cmdList->CopyBufferRegion(_indexBuffer.Get(), 0, uploadBuffer.Get(), 0, desc.ByteWidth); + + // CD3DX12_RESOURCE_BARRIER barriers[1] = { + // CD3DX12_RESOURCE_BARRIER::Transition(_indexBuffer.Get(), + // D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_INDEX_BUFFER) + // }; + + + // cmdList->ResourceBarrier(1, barriers); + // renderer->EndCommandList(); + // renderer->WaitCommandsQueue(); + } + index_count_t GetIndicesCount() const { + return _indexCount; + } +private: + index_count_t _indexCount; + MeshTopology _topology; + //ID3D12ResourcePtr _indexBuffer; + D3D12_INDEX_BUFFER_VIEW _indexBufferView; +}; + +typedef std::shared_ptr SubmeshPtr; diff --git a/Src/RenderFramework/SwapChainOutput.h b/Src/RenderFramework/SwapChainOutput.h new file mode 100644 index 0000000..cb61d2b --- /dev/null +++ b/Src/RenderFramework/SwapChainOutput.h @@ -0,0 +1,122 @@ +#pragma once + +#include "RenderOutput.h" +#include "Renderer.h" + + +class SwapChainOutput : public RenderOutput { +public: + SwapChainOutput(RendererPtr renderer, HWND window, uint32_t width, uint32_t height, bool stereo) : _activeBuffer(0){ + /*_buffersCount = 2; + _swapChain = renderer->CreateSwapChain(window, true, width, height, _buffersCount, stereo); + auto device = renderer->GetDevice(); + + //create RTV descriptors heap + D3D12_DESCRIPTOR_HEAP_DESC heap_desc = {}; + heap_desc.NumDescriptors = _buffersCount; + heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV; + heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; + + HR_ASSERT_MSG(device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&rtvDescriptorHeap)), L"Failed to allocate RTV descriptors heap"); + rtvDescriptorHeap->SetName(L"RTV Heap"); + + rtvDescSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV); + CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart()); + + + //create DSV descriptors heap + heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV; + HR_ASSERT_MSG(device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&dsvDescriptorHeap)), L"Failed to allocate DSV descriptors heap"); + dsvDescriptorHeap->SetName(L"DSV Heap"); + + dsvDescSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV); + CD3DX12_CPU_DESCRIPTOR_HANDLE dsvHandle(dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart()); + + for(uint32_t i = 0; i < _buffersCount; ++i){ + //get back buffer + ID3D12ResourcePtr _backBuffer; + if (FAILED(_swapChain->GetBuffer(i, IID_PPV_ARGS(&_backBuffer)))){ + FatalError(TEXT("Failed to get swap chain's bffer")); + } + device->CreateRenderTargetView(_backBuffer.Get(), nullptr, rtvHandle); + + + + //create depth buffer + D3D12_CLEAR_VALUE depthOptimizedClearValue = {}; + depthOptimizedClearValue.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; + depthOptimizedClearValue.DepthStencil.Depth = 1.0f; + depthOptimizedClearValue.DepthStencil.Stencil = 0; + + ComPtr depthStencilBuffer; + device->CreateCommittedResource( + &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), + D3D12_HEAP_FLAG_NONE, + &CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_D24_UNORM_S8_UINT, width, height, 1, 0, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL), + D3D12_RESOURCE_STATE_DEPTH_WRITE, + &depthOptimizedClearValue, + IID_PPV_ARGS(&depthStencilBuffer) + ); + + device->CreateDepthStencilView(depthStencilBuffer.Get(), nullptr, dsvHandle); + + rtvHandle.Offset(1, rtvDescSize); + dsvHandle.Offset(1, dsvDescSize); + _buffers.push_back({ _backBuffer, depthStencilBuffer }); + } */ + } + virtual uint32_t GetWidth() override{ + return GetDesc().Width; + } + + virtual uint32_t GetHeight() override + { + return GetDesc().Height; + } + + // CD3DX12_CPU_DESCRIPTOR_HANDLE GetRenderTargetDescriptor(uint32_t id) override { + // return CD3DX12_CPU_DESCRIPTOR_HANDLE(rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), id, rtvDescSize); + // } + // CD3DX12_CPU_DESCRIPTOR_HANDLE GetDepthStencilDescriptor(uint32_t id) override { + // return CD3DX12_CPU_DESCRIPTOR_HANDLE(dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), id, dsvDescSize); + // } + + // ID3D12ResourcePtr GetRenderTarget(uint32_t id) override{ + // return _buffers[id].first; + // } + + // ID3D12ResourcePtr GetDepthBuffer(uint32_t id) override { + // return _buffers[id].second; + // } + + virtual void Present() override{ + //_swapChain->Present(0, 0); + _activeBuffer = (_activeBuffer + 1) % _buffersCount; + } + + virtual void OnPreRender(RendererPtr renderer) override{ + + } + + DXGI_SWAP_CHAIN_DESC1 GetDesc() { + DXGI_SWAP_CHAIN_DESC1 desc; + //_swapChain->GetDesc1(&desc); + return desc; + } + uint32_t GetCurrentBufferIndex() override{ + return _activeBuffer; + } + uint32_t GetBuffersCount() override{ + return _buffersCount; + } +private: + // std::vector> _buffers; + uint32_t _activeBuffer; + uint32_t _buffersCount; + UINT rtvDescSize; + UINT dsvDescSize; + // ComPtr rtvDescriptorHeap; + // ComPtr dsvDescriptorHeap; + // IDXGISwapChain1Ptr _swapChain; + +}; diff --git a/Src/RenderFramework/Texture.h b/Src/RenderFramework/Texture.h new file mode 100644 index 0000000..0a75a0b --- /dev/null +++ b/Src/RenderFramework/Texture.h @@ -0,0 +1,15 @@ +#pragma once + + +class Texture +{ +public: + Texture(/*ID3D12ResourcePtr _resource, D3D12_CPU_DESCRIPTOR_HANDLE _srvDescriptor*/) + /*:resource(_resource), srvDescriptor(_srvDescriptor)*/ + { + + } + //ID3D12ResourcePtr resource; + //D3D12_CPU_DESCRIPTOR_HANDLE srvDescriptor; +}; + diff --git a/Src/RenderFramework/TextureImporter.h b/Src/RenderFramework/TextureImporter.h new file mode 100644 index 0000000..c107185 --- /dev/null +++ b/Src/RenderFramework/TextureImporter.h @@ -0,0 +1,33 @@ +#ifndef TextureImporter_h__ +#define TextureImporter_h__ + +#include "AssetImporter.h" +#include + +/* +class TextureImporter : public AssetImporter { +public: + virtual bool can_import(const std::wstring& path) const override { + std::tr2::sys::path file_path(path); + if (!file_path.has_extension()) { + return false; + } else { + return file_path.extension() == ".bmp"; + } + } + + virtual bool load_parameters(const std::wstring& params) override { + throw std::logic_error("The method or operation is not implemented."); + } + + virtual std::wstring save_parameters() override { + throw std::logic_error("The method or operation is not implemented."); + } + + virtual std::wstring name() override { + return L"TextureImporter"; + } + +};*/ + +#endif // TextureImporter_h__ diff --git a/Src/RenderFramework/Transform.h b/Src/RenderFramework/Transform.h new file mode 100644 index 0000000..a8cf0c5 --- /dev/null +++ b/Src/RenderFramework/Transform.h @@ -0,0 +1,94 @@ +#ifndef Transform_h__ +#define Transform_h__ + +#include +#include "Mathf.h" +#include "ObjectsFactory.h" +#include "Component.h" +#include "Archive.h" + +using namespace lm; + +LOBJECT(Transform, Component) +public: + std::shared_ptr parent; + Quaternion_f _rotation; + float3 _position; + float3 _scale; + + Transform() + :_scale(1.0f,1.0f,1.0f), _position(0.0f,0.0f,0.0f), _rotation(0.0f,0.0f,0.0f,1.0f){ + } + + void serialize(Archive& archive) override{ + Component::serialize(archive); + archive << parent; + archive << _rotation << _position << _scale; + } + + std::wstring class_name() const { + return L"Transform"; + } + + void SetLocalPosition(const float3& position) { + _position = position; + } + float3 GetLocalPosition() { + return _position; + } + + float3 forward() const{ + return GetGlobalTransform().z().xyz(); + } + + float3 right() const { + return GetGlobalTransform().x().xyz(); + } + + float3 up() const { + return GetGlobalTransform().y().xyz(); + } + + void SetLocalRotation(const Quaternion_f& rotation) { + _rotation = rotation; + } + + Quaternion_f GetLocalRotation() { + return _rotation; + } + + void SetLocalScale(const float3& scale) { + _scale = scale; + } + + float3 GetLocalScale() { + return _scale; + } + + float4x4 GetLocalTransform() const{ + auto scaleMatrix = matrix4x4Scale(_scale); + auto rotationMatrix = matrix4x4RotationQuaternion(_rotation); + auto positionMatrix = matrix4x4Translation(_position); + return lm::mul(lm::mul(scaleMatrix, rotationMatrix), positionMatrix); + } + + float4x4 GetGlobalTransform() const{ + if(parent == nullptr) { + return GetLocalTransform(); + } + return lm::mul(GetLocalTransform(), parent->GetGlobalTransform()); + } + + float3 GetGlobalPosition() { + auto tf = GetGlobalTransform(); + return float3(tf[0][3], tf[1][3], tf[2][3]); + } + + void RotateLocal(const Quaternion_f& rotation) { + _rotation = lm::mul(_rotation, rotation); + } +}; + + + +#endif // Transform_h__ diff --git a/Src/RenderFramework/Vertex.h b/Src/RenderFramework/Vertex.h new file mode 100644 index 0000000..2eb78cb --- /dev/null +++ b/Src/RenderFramework/Vertex.h @@ -0,0 +1,27 @@ +#ifndef Vertex_h__ +#define Vertex_h__ + +#include + +using namespace lm; +struct Vertex { + float4 position; + float3 normal; + float2 uv0; + float2 uv1; + + Vertex() { + + } + + Vertex(float4 _pos, float3 _norm) { + position = _pos; + normal = _norm; + } + Vertex(float4 _pos, float3 _norm, float2 _uv0) { + position = _pos; + normal = _norm; + uv0 = _uv0; + } +}; +#endif // Vertex_h__ diff --git a/Src/RenderFramework/Vulkan/Application.cpp b/Src/RenderFramework/Vulkan/Application.cpp new file mode 100644 index 0000000..b7a2bf9 --- /dev/null +++ b/Src/RenderFramework/Vulkan/Application.cpp @@ -0,0 +1,775 @@ +#include "Application.h" + + +#include "VertexShader_unknown.h" +#include "FragmentShader_unknown.h" +#include +#include "VulkanDeviceFunctions.h" + +Application::Application() { + vulkan = std::make_shared(); + auto extensions = vulkan->getSupportedExtensions(); + auto layers = vulkan->getSupportedLayers(); + + if(std::find_if(layers.begin(), layers.end(), [](VkLayerProperties& layer){ return std::string(layer.layerName) == "VK_LAYER_KHRONOS_validation"; } ) == layers.end()){ + throw std::runtime_error("Validation layer not found"); + } + + VulkanApplicationInfo appInfo("Test project", 1, "Test"); + + std::vector instanceLayers; + instanceLayers.push_back("VK_LAYER_KHRONOS_validation"); + + auto instance = vulkan->createInstance(appInfo, 0, instanceLayers, RenderWindow::getRequiredExtensionNames()); + + auto physicalDevices = instance->enumeratePhysicalDevices(); + device = physicalDevices[0]; + + + auto properties = device->getProperties(); + auto features = device->getFeatures(); + auto families = device->getQueueFamilyProperties(); + + window = new RenderWindow(instance, "VulkanWrapperSandbox"); + + std::cout << "Device queue families count: " << device->getQueueFamiliesCount() << std::endl; + + //Find queues + + for (uint32_t i = 0; i < device->getQueueFamiliesCount(); ++i) { + if (presentQueueFamilyIndex == -1 && families[i].queueCount > 0 && window->canPresent(device, i)) { + presentQueueFamilyIndex = i; + std::cout << "Found present queue: " << i << std::endl; + } + + if (renderQueueFamilyIndex == -1 && families[i].isGraphics() && families[i].queueCount > 0) { + std::cout << "Found render queue: " << i << std::endl; + renderQueueFamilyIndex = i; + } + + if (renderQueueFamilyIndex != -1 && presentQueueFamilyIndex != -1) { + break; + } + } + + std::vector queueDescriptions; + queueDescriptions.push_back(VulkanQueueCreateInfo(presentQueueFamilyIndex, { 1.0f })); + if (presentQueueFamilyIndex != renderQueueFamilyIndex) { + queueDescriptions.push_back(VulkanQueueCreateInfo(renderQueueFamilyIndex, { 1.0f })); + } + + auto deviceExtensions = device->getExtensions(); + + std::vector requiredDeviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }; + + auto swapChainExt = std::find_if(deviceExtensions.begin(), deviceExtensions.end(), [&requiredDeviceExtensions](VkExtensionProperties ext) { return std::string(requiredDeviceExtensions[0]) == ext.extensionName; }); + if (swapChainExt == deviceExtensions.end()) { + throw std::runtime_error("Failed to find device with swap chain extension"); + } + + logicalDevice = IntrusivePtr(new VulkanLogicalDevice(device, requiredDeviceExtensions, {}, queueDescriptions)); + + + VkCommandPoolCreateInfo poolCreateInfo = {}; + poolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + poolCreateInfo.queueFamilyIndex = presentQueueFamilyIndex; + poolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + + if (logicalDevice->functions().vkCreateCommandPool(&poolCreateInfo, nullptr, &presentCommandPool) != VK_SUCCESS) { + std::cerr << "failed to create command queue for presentation queue family" << std::endl; + exit(1); + } + else { + std::cout << "created command pool for presentation queue family" << std::endl; + } + + if (renderQueueFamilyIndex == presentQueueFamilyIndex) { + renderCommandPool = presentCommandPool; + } + else { + poolCreateInfo.queueFamilyIndex = renderQueueFamilyIndex; + if (logicalDevice->functions().vkCreateCommandPool(&poolCreateInfo, nullptr, &renderCommandPool) != VK_SUCCESS) { + std::cerr << "failed to create command queue for render queue family" << std::endl; + exit(1); + } + else { + std::cout << "created command pool for render queue family" << std::endl; + } + } + + queues = logicalDevice->queues(); + + std::vector vertexData = + { + { { 1.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f } }, + { { -1.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f } }, + { { 0.0f, 1.0f, 0.0f }, { 0.0f, 0.0f, 1.0f } } + }; + _vertexBuffer = createBuffer(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, vertexData.data(), sizeof(vertexData[0]) * vertexData.size(), logicalDevice, device, queues[0], renderCommandPool); + + std::vector indexData = { 0, 1, 2 }; + _indexBuffer = createBuffer(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, indexData.data(), sizeof(indexData[0]) * indexData.size(), logicalDevice, device, queues[0], renderCommandPool); + + createSwapChain(); + + //for(std::size_t i = 0; i < swapChain->images) + //_frameBuffers + + //logicalDevice->functions().vkGetDeviceQueue() + + for (auto image : swapChain->images()) { + _imageViews.push_back(IntrusivePtr(new VulkanImageView(logicalDevice, VulkanImageViewCreateInfo::image2D(image, swapChain->format())))); + } + + presentCommandBuffers.resize(swapChain->images().size()); + VkCommandBufferAllocateInfo allocInfo = {}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.commandPool = presentCommandPool; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandBufferCount = static_cast(swapChain->images().size()); + if (logicalDevice->functions().vkAllocateCommandBuffers(&allocInfo, presentCommandBuffers.data()) != VK_SUCCESS) { + std::cerr << "failed to allocate presentation command buffers" << std::endl; + exit(1); + } + + VkFenceCreateInfo fenceInfo{}; + fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; + _cmdBufferFences.resize(swapChain->images().size()); + for(std::size_t i = 0; i < swapChain->images().size(); ++i){ + if(logicalDevice->functions().vkCreateFence(&fenceInfo, nullptr, &_cmdBufferFences[i]) != VK_SUCCESS) { + throw std::runtime_error("failed to create synchronization objects for a frame!"); + } + + _uniformBuffers.push_back(IntrusivePtr(new UniformBuffer(logicalDevice, sizeof(UboPerObjectData)))); + } + // + + + + compileShaders(); + + + + VkAttachmentDescription colorAttachment = {}; + colorAttachment.format = swapChain->format(); + colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT; + colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; + colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + + VkAttachmentReference colorAttachmentRef = {}; + colorAttachmentRef.attachment = 0; + colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + VkSubpassDescription subpass = {}; + subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &colorAttachmentRef; + + VkRenderPassCreateInfo renderPassInfo = {}; + renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + renderPassInfo.attachmentCount = 1; + renderPassInfo.pAttachments = &colorAttachment; + renderPassInfo.subpassCount = 1; + renderPassInfo.pSubpasses = &subpass; + + + //Create render pass + if (logicalDevice->functions().vkCreateRenderPass(&renderPassInfo, nullptr, &_renderPass) != VK_SUCCESS) { + throw std::runtime_error("failed to create render pass!"); + } + + + + for (auto& imageView : _imageViews) { + VkImageView attachments[] = { + imageView->native() + }; + + VkFramebufferCreateInfo framebufferInfo{}; + framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebufferInfo.renderPass = _renderPass; + framebufferInfo.attachmentCount = 1; + framebufferInfo.pAttachments = attachments; + framebufferInfo.width = swapChain->extent().width; + framebufferInfo.height = swapChain->extent().height; + framebufferInfo.layers = 1; + + // + _frameBuffers.push_back(IntrusivePtr(new VulkanFrameBuffer(logicalDevice, framebufferInfo))); + } + + + //Descriptor set layout for UBO + VkDescriptorSetLayoutBinding uboLayoutBinding{}; + uboLayoutBinding.binding = 0; + uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + uboLayoutBinding.descriptorCount = 1; + uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + uboLayoutBinding.pImmutableSamplers = nullptr; // Optional + + VkDescriptorSetLayoutCreateInfo layoutInfo{}; + layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layoutInfo.bindingCount = 1; + layoutInfo.pBindings = &uboLayoutBinding; + + _uboDescriptorSetLayout = IntrusivePtr(new VulkanDescriptorSetLayout(logicalDevice, layoutInfo)); + + //Create pipeline + createPipeline(); + + + + + + +} + +void Application::createPipeline(){ + VkPipelineShaderStageCreateInfo vertShaderStageInfo{}; + vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; + vertShaderStageInfo.module = vs->native(); + vertShaderStageInfo.pName = "main"; + vertShaderStageInfo.pSpecializationInfo = nullptr; + + VkPipelineShaderStageCreateInfo fragShaderStageInfo{}; + fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + fragShaderStageInfo.module = ps->native(); + fragShaderStageInfo.pName = "main"; + + VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo}; + + + //Bind vertex data + VkPipelineVertexInputStateCreateInfo vertexInputInfo{}; + vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + + auto bindingDescription = Vertex::getBindingDescription(); + vertexInputInfo.vertexBindingDescriptionCount = 1; + vertexInputInfo.pVertexBindingDescriptions = &bindingDescription; // Optional + + auto attributeDescriptions = Vertex::getAttributeDescriptions(); + vertexInputInfo.vertexAttributeDescriptionCount = attributeDescriptions.size(); + vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data(); // Optional + + //Input assembly + VkPipelineInputAssemblyStateCreateInfo inputAssembly{}; + inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + inputAssembly.primitiveRestartEnable = VK_FALSE; + + //Viewport + VkViewport viewport = {}; + viewport.x = 0.0f; + viewport.y = 0.0f; + viewport.width = (float)swapChain->extent().width; + viewport.height = (float)swapChain->extent().height; + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.0f; + + //Scissor + VkRect2D scissor = {}; + scissor.offset = { 0, 0 }; + scissor.extent = swapChain->extent(); + + //Pipeline Viewport State + VkPipelineViewportStateCreateInfo viewportState = {}; + viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + viewportState.viewportCount = 1; + viewportState.pViewports = &viewport; + viewportState.scissorCount = 1; + viewportState.pScissors = &scissor; + + //Rasterizer + VkPipelineRasterizationStateCreateInfo rasterizer = {}; + rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterizer.depthClampEnable = VK_FALSE; + rasterizer.rasterizerDiscardEnable = VK_FALSE; + rasterizer.polygonMode = VK_POLYGON_MODE_FILL; + rasterizer.lineWidth = 1.0f; + rasterizer.cullMode = VK_CULL_MODE_NONE; //VK_CULL_MODE_BACK_BIT; + rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE; + rasterizer.depthBiasEnable = VK_FALSE; + rasterizer.depthBiasConstantFactor = 0.0f; // Optional + rasterizer.depthBiasClamp = 0.0f; // Optional + rasterizer.depthBiasSlopeFactor = 0.0f; // Optional + + //Multisample + VkPipelineMultisampleStateCreateInfo multisampling = {}; + multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisampling.sampleShadingEnable = VK_FALSE; + multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + multisampling.minSampleShading = 1.0f; // Optional + multisampling.pSampleMask = nullptr; // Optional + multisampling.alphaToCoverageEnable = VK_FALSE; // Optional + multisampling.alphaToOneEnable = VK_FALSE; // Optional + + //Pipeline layout + VkPipelineLayoutCreateInfo pipelineLayoutInfo{}; + pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + pipelineLayoutInfo.setLayoutCount = 1; + VkDescriptorSetLayout layout = _uboDescriptorSetLayout->native(); + pipelineLayoutInfo.pSetLayouts = &layout; + pipelineLayoutInfo.pushConstantRangeCount = 0; + + auto pipelineLayout = IntrusivePtr(new VulkanPipelineLayout(logicalDevice, pipelineLayoutInfo)); + + //Blend state attachment + VkPipelineColorBlendAttachmentState colorBlendAttachment = {}; + colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; + colorBlendAttachment.blendEnable = VK_FALSE; + colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional + colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional + colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional + colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional + colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional + colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional + + //Blend state + VkPipelineColorBlendStateCreateInfo colorBlending{}; + colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + colorBlending.logicOpEnable = VK_FALSE; + colorBlending.logicOp = VK_LOGIC_OP_COPY; + colorBlending.attachmentCount = 1; + colorBlending.pAttachments = &colorBlendAttachment; + colorBlending.blendConstants[0] = 0.0f; + colorBlending.blendConstants[1] = 0.0f; + colorBlending.blendConstants[2] = 0.0f; + colorBlending.blendConstants[3] = 0.0f; + + + //Pipeline + VkGraphicsPipelineCreateInfo pipelineInfo{}; + pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + pipelineInfo.stageCount = 2; + pipelineInfo.pStages = shaderStages; + pipelineInfo.pVertexInputState = &vertexInputInfo; + pipelineInfo.pInputAssemblyState = &inputAssembly; + pipelineInfo.pViewportState = &viewportState; + pipelineInfo.pRasterizationState = &rasterizer; + pipelineInfo.pMultisampleState = &multisampling; + pipelineInfo.pColorBlendState = &colorBlending; + pipelineInfo.pDynamicState = nullptr; + pipelineInfo.layout = pipelineLayout->native(); + pipelineInfo.renderPass = _renderPass; + pipelineInfo.subpass = 0; + pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + + _pipeline = IntrusivePtr(new VulkanPipeline(logicalDevice, pipelineLayout, pipelineInfo)); + +} + + +void Application::compileShaders() { + auto vertexBinary = ShaderCompiler::compile(vert, ShaderCompilerStage::vert); + + + spv_reflect::ShaderModule sm(vertexBinary.binary.size(), vertexBinary.binary.data()); + auto name = sm.GetEntryPointName(); + + + + uint32_t count = 0; + auto res = sm.EnumerateDescriptorSets(&count, nullptr); + std::vector descriptorSets(count); + res = sm.EnumerateDescriptorSets(&count, descriptorSets.data()); + + for(uint32_t i = 0; i < count; ++i){ + SpvReflectDescriptorSet* v = descriptorSets[i]; + std::cout << "V" << std::endl; + } + + + auto fragmentBinary = ShaderCompiler::compile(frag, ShaderCompilerStage::frag); + + + + vs = IntrusivePtr(new VulkanShaderModule(logicalDevice, vertexBinary.binary.data(), vertexBinary.binary.size())); + ps = IntrusivePtr(new VulkanShaderModule(logicalDevice, fragmentBinary.binary.data(), fragmentBinary.binary.size())); +} + +void Application::createSwapChain() { + auto formats = VulkanSwapChain::getSurfaceFormats(device, window->getSurface()); + auto caps = VulkanSwapChain::getSurfaceCapabilities(device, window->getSurface()); + auto presentModes = VulkanSwapChain::getPresentModes(device, window->getSurface()); + + VkSwapchainCreateInfoKHR createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + createInfo.pNext = NULL; + createInfo.surface = window->getSurface(); + createInfo.imageFormat = formats[0].format; + createInfo.imageColorSpace = formats[0].colorSpace; + createInfo.minImageCount = caps.minImageCount + 1; + createInfo.imageExtent = caps.currentExtent; + createInfo.preTransform = caps.currentTransform; + createInfo.presentMode = VK_PRESENT_MODE_MAILBOX_KHR; + createInfo.imageArrayLayers = 1; + createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; + + std::vector swapChainQueueFamilies; + swapChainQueueFamilies.push_back(renderQueueFamilyIndex); + swapChainQueueFamilies.push_back(presentQueueFamilyIndex); + + if (presentQueueFamilyIndex == renderQueueFamilyIndex) { + createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; + createInfo.queueFamilyIndexCount = 0; // Optional + createInfo.pQueueFamilyIndices = nullptr; // Optional + } + else { + createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; + createInfo.queueFamilyIndexCount = 2; + createInfo.pQueueFamilyIndices = &swapChainQueueFamilies[0]; + } + createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; + createInfo.clipped = VK_TRUE; + createInfo.oldSwapchain = VK_NULL_HANDLE; + + + swapChain = new VulkanSwapChain(logicalDevice, createInfo); +} + +void Application::recordCommandBuffer(VkCommandBuffer cmdBuffer, uint32_t cmdBufferIndex, uint32_t imageIndex){ + VkCommandBufferBeginInfo beginInfo = {}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; + + VkImageSubresourceRange subResourceRange = {}; + subResourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + subResourceRange.baseMipLevel = 0; + subResourceRange.levelCount = 1; + subResourceRange.baseArrayLayer = 0; + subResourceRange.layerCount = 1; + + + VkImageMemoryBarrier presentToClearBarrier = {}; + presentToClearBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + presentToClearBarrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT; + presentToClearBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + presentToClearBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; + presentToClearBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + presentToClearBarrier.srcQueueFamilyIndex = presentQueueFamilyIndex; + presentToClearBarrier.dstQueueFamilyIndex = presentQueueFamilyIndex; + presentToClearBarrier.image = swapChain->images()[imageIndex]; + presentToClearBarrier.subresourceRange = subResourceRange; + + // Change layout of image to be optimal for presenting + VkImageMemoryBarrier clearToPresentBarrier = {}; + clearToPresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + clearToPresentBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + clearToPresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT; + clearToPresentBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + clearToPresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + clearToPresentBarrier.srcQueueFamilyIndex = presentQueueFamilyIndex; + clearToPresentBarrier.dstQueueFamilyIndex = presentQueueFamilyIndex; + clearToPresentBarrier.image = swapChain->images()[imageIndex]; + clearToPresentBarrier.subresourceRange = subResourceRange; + + // Record command buffer + logicalDevice->functions().vkBeginCommandBuffer(presentCommandBuffers[imageIndex], &beginInfo); + + logicalDevice->functions().vkCmdPipelineBarrier(presentCommandBuffers[imageIndex], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &presentToClearBarrier); + + //logicalDevice->functions().vkCmdClearColorImage(presentCommandBuffers[i], swapChain->images()[i], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColors[i % 3], 1, &subResourceRange); + + VkClearColorValue clearColors[3] = { + {{ 1.0f, 0, 0, 1.0f }}, + {{ 0, 1, 0, 1.0f }}, + {{ 0, 0, 1, 1.0f }} + }; + + VkRenderPassBeginInfo renderPassInfo{}; + renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + renderPassInfo.renderPass = _renderPass; + renderPassInfo.framebuffer = _frameBuffers[imageIndex]->native(); + renderPassInfo.renderArea.offset = {0, 0}; + renderPassInfo.renderArea.extent = swapChain->extent(); + + VkClearValue clearColor = {{{0.0f, 0.0f, 1.0f, 1.0f}}}; + renderPassInfo.clearValueCount = 1; + renderPassInfo.pClearValues = &clearColor; + + logicalDevice->functions().vkCmdBeginRenderPass(cmdBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE); + logicalDevice->functions().vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, _pipeline->native()); + + //VkViewport viewport{}; + //viewport.x = 0.0f; + //viewport.y = 0.0f; + //viewport.width = (float) swapChain->extent().width; + //viewport.height = (float) swapChain->extent().height; + //viewport.minDepth = 0.0f; + //viewport.maxDepth = 1.0f; + //logicalDevice->functions().vkCmdSetViewport(cmdBuffer, 0, 1, &viewport); +// + //VkRect2D scissor{}; + //scissor.offset = {0, 0}; + //scissor.extent = swapChain->extent(); + //logicalDevice->functions().vkCmdSetScissor(cmdBuffer, 0, 1, &scissor); + + VkBuffer vertexBuffers[] = {_vertexBuffer->native()}; + VkDeviceSize offsets[] = {0}; + logicalDevice->functions().vkCmdBindVertexBuffers(cmdBuffer, 0, 1, vertexBuffers, offsets); + + logicalDevice->functions().vkCmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, _pipeline->layout()->native(), 0, 1, &descriptorSets[cmdBufferIndex], 0, nullptr); + + auto vertexCount = _vertexBuffer->size() / sizeof(Vertex); + logicalDevice->functions().vkCmdDraw(cmdBuffer, static_cast(vertexCount), 1, 0, 0); + logicalDevice->functions().vkCmdEndRenderPass(cmdBuffer); + + + + logicalDevice->functions().vkCmdPipelineBarrier(presentCommandBuffers[imageIndex], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &clearToPresentBarrier); + + if (logicalDevice->functions().vkEndCommandBuffer(presentCommandBuffers[imageIndex]) != VK_SUCCESS) { + std::cerr << "failed to record command buffer" << std::endl; + exit(1); + } + else { + std::cout << "recorded command buffer for image " << imageIndex << std::endl; + } +} + + +void Application::updateUniformBuffer(uint32_t currentImage){ + static auto startTime = std::chrono::high_resolution_clock::now(); + auto currentTime = std::chrono::high_resolution_clock::now(); + float time = std::chrono::duration(currentTime - startTime).count(); + + UboPerObjectData ubo{}; + ubo.model = glm::rotate(glm::mat4(1.0f), time * glm::radians(90.0f), glm::vec3(0.0f, 1.0f, 0.0f)); + ubo.view = glm::lookAtLH(glm::vec3(0.0f, 2.0f, -2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f)); + ubo.proj = glm::perspectiveLH(glm::radians(90.0f), swapChain->extent().width / (float) swapChain->extent().height, 0.1f, 10.0f); + ubo.proj[1][1] *= -1; + + memcpy(_uniformBuffers[currentImage]->mappedMemory(), &ubo, sizeof(ubo)); +} + +void Application::run() { + auto swapChainImageCount = swapChain->images().size(); + + std::vector> imageAvailableSemaphores; + std::vector> renderingFinishedSemaphores; + + for(std::size_t i = 0; i < _cmdBufferFences.size(); ++i){ + imageAvailableSemaphores.push_back(IntrusivePtr(new VulkanSemaphore(logicalDevice))); + renderingFinishedSemaphores.push_back(IntrusivePtr(new VulkanSemaphore(logicalDevice))); + } + + auto uboDescriptorPool = createDescriptorPool(_cmdBufferFences.size()); + std::vector layouts(_cmdBufferFences.size(), _uboDescriptorSetLayout->native()); + VkDescriptorSetAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + allocInfo.descriptorPool = uboDescriptorPool; + allocInfo.descriptorSetCount = static_cast(_cmdBufferFences.size()); + allocInfo.pSetLayouts = layouts.data(); + + descriptorSets.resize(_cmdBufferFences.size()); + if (logicalDevice->functions().vkAllocateDescriptorSets(&allocInfo, descriptorSets.data()) != VK_SUCCESS) { + throw std::runtime_error("failed to allocate descriptor sets!"); + } + for (size_t i = 0; i < _cmdBufferFences.size(); i++) { + VkDescriptorBufferInfo bufferInfo{}; + bufferInfo.buffer = _uniformBuffers[i]->buffer()->native(); + bufferInfo.offset = 0; + bufferInfo.range = sizeof(UboPerObjectData); + + VkWriteDescriptorSet descriptorWrite{}; + descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorWrite.dstSet = descriptorSets[i]; + descriptorWrite.dstBinding = 0; + descriptorWrite.dstArrayElement = 0; + descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptorWrite.descriptorCount = 1; + descriptorWrite.pBufferInfo = &bufferInfo; + descriptorWrite.pImageInfo = nullptr; // Optional + descriptorWrite.pTexelBufferView = nullptr; // Optional + logicalDevice->functions().vkUpdateDescriptorSets(1, &descriptorWrite, 0, nullptr); + } + + + + std::cout << "allocated presentation command buffers" << std::endl; + + int cmdBufferIndex = 0; + + while (window->update()) { + //Wait cmd buffer to finish it's job to use it again + logicalDevice->functions().vkWaitForFences(1, &_cmdBufferFences[cmdBufferIndex], VK_TRUE, UINT64_MAX); + + + std::uint32_t imageIndex = 0; + auto result = logicalDevice->functions().vkAcquireNextImageKHR(swapChain->native(), UINT64_MAX, imageAvailableSemaphores[cmdBufferIndex]->native(), nullptr, &imageIndex); + if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) { + std::cerr << "failed to acquire image" << std::endl; + exit(1); + } + + updateUniformBuffer(cmdBufferIndex); + + logicalDevice->functions().vkResetFences(1, &_cmdBufferFences[cmdBufferIndex]); + + logicalDevice->functions().vkResetCommandBuffer(presentCommandBuffers[cmdBufferIndex], /*VkCommandBufferResetFlagBits*/ 0); + recordCommandBuffer(presentCommandBuffers[cmdBufferIndex], cmdBufferIndex, imageIndex); + + + + VkSubmitInfo submitInfo = {}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + + submitInfo.waitSemaphoreCount = 1; + submitInfo.pWaitSemaphores = &imageAvailableSemaphores[cmdBufferIndex]->native(); + submitInfo.signalSemaphoreCount = 1; + submitInfo.pSignalSemaphores = &renderingFinishedSemaphores[cmdBufferIndex]->native(); + + // This is the stage where the queue should wait on the semaphore (it doesn't have to wait with drawing, for example) + VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT; + submitInfo.pWaitDstStageMask = &waitDstStageMask; + + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &presentCommandBuffers[cmdBufferIndex]; + + if (logicalDevice->functions().vkQueueSubmit(queues[0].queue, 1, &submitInfo, _cmdBufferFences[cmdBufferIndex]) != VK_SUCCESS) { + std::cerr << "failed to submit draw command buffer" << std::endl; + exit(1); + } + + // std::cout << "submitted draw command buffer" << std::endl; + + // Present drawn image + // Note: semaphore here is not strictly necessary, because commands are processed in submission order within a single queue + VkPresentInfoKHR presentInfo = {}; + presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + presentInfo.waitSemaphoreCount = 1; + presentInfo.pWaitSemaphores = &renderingFinishedSemaphores[cmdBufferIndex]->native(); + + auto nativeSwapChain = swapChain->native(); + presentInfo.swapchainCount = 1; + presentInfo.pSwapchains = &nativeSwapChain; + presentInfo.pImageIndices = &imageIndex; + + auto res = logicalDevice->functions().vkQueuePresentKHR(queues[0].queue, &presentInfo); + + if (res != VK_SUCCESS) { + std::cerr << "failed to submit present command buffer" << std::endl; + exit(1); + } + + cmdBufferIndex = (cmdBufferIndex + 1) % _cmdBufferFences.size(); + //std::cout << "submitted presentation command buffer for image " << imageIndex << std::endl; + + + + //std::this_thread::sleep_for(std::chrono::milliseconds(100)); + } + + std::cout << "Test" << std::endl; +} + +void Application::copyBufferHostToDevice(IntrusivePtr device, VulkanQueue queue, VkCommandPool pool, IntrusivePtr hostBuffer, IntrusivePtr deviceBuffer) { + VkCommandBuffer cmdBuffer; + + VkCommandBufferAllocateInfo allocInfo = {}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.commandPool = pool; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandBufferCount = 1; + + if (device->functions().vkAllocateCommandBuffers(&allocInfo, &cmdBuffer) != VK_SUCCESS) { + throw std::runtime_error("Failed to allocate command buffer"); + } + + // If requested, also start the new command buffer + VkCommandBufferBeginInfo beginInfo = {}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; + device->functions().vkBeginCommandBuffer(cmdBuffer, &beginInfo); + + + VkBufferCopy copyRegion = {}; + copyRegion.size = hostBuffer->getMemoryRequirements().size; + + device->functions().vkCmdCopyBuffer(cmdBuffer, hostBuffer->native(), deviceBuffer->native(), 1, ©Region); + + device->functions().vkEndCommandBuffer(cmdBuffer); + + VkSubmitInfo submitInfo = {}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &cmdBuffer; + + // Create fence to ensure that the command buffer has finished executing + VkFenceCreateInfo fenceCreateInfo = {}; + fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fenceCreateInfo.flags = 0; + VkFence fence; + device->functions().vkCreateFence(&fenceCreateInfo, nullptr, &fence); + + // Submit to the queue + device->functions().vkQueueSubmit(queue.queue, 1, &submitInfo, fence); + // Wait for the fence to signal that command buffer has finished executing + device->functions().vkWaitForFences(1, &fence, VK_TRUE, DEFAULT_FENCE_TIMEOUT); + + device->functions().vkDestroyFence(fence, nullptr); + device->functions().vkFreeCommandBuffers(pool, 1, &cmdBuffer); + +} + +IntrusivePtr Application::createBuffer(VkBufferUsageFlagBits usage, const void* data, VkDeviceSize size, IntrusivePtr logicalDevice, IntrusivePtr device, VulkanQueue queue, VkCommandPool commandPool) { + auto memoryProps = device->getMemoryProperties(); + + auto stagingBuffer = IntrusivePtr(new VulkanBuffer(logicalDevice, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT)); + auto memoryRequirements = stagingBuffer->getMemoryRequirements(); + auto suitableIndices = memoryProps.findSuitableMemoryTypeIndices(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, memoryRequirements.memoryTypeBits); + + auto stagingBufferMemory = IntrusivePtr(new VulkanMemory(logicalDevice, memoryRequirements.size, suitableIndices[0])); + stagingBufferMemory->write(data, size); + + stagingBuffer->bindMemory(stagingBufferMemory); + + + auto result = IntrusivePtr(new VulkanBuffer(logicalDevice, size, usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT)); + memoryRequirements = result->getMemoryRequirements(); + suitableIndices = memoryProps.findSuitableMemoryTypeIndices(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, memoryRequirements.memoryTypeBits); + auto resultMemory = IntrusivePtr(new VulkanMemory(logicalDevice, memoryRequirements.size, suitableIndices[0])); + result->bindMemory(resultMemory); + + copyBufferHostToDevice(logicalDevice, queue, commandPool, stagingBuffer, result); + + return result; +} + + +VkDescriptorPool Application::createDescriptorPool(std::size_t descriptorCount) +{ + // We need to tell the API the number of max. requested descriptors per type + VkDescriptorPoolSize typeCounts[1]; + // This example only uses one descriptor type (uniform buffer) and only requests one descriptor of this type + typeCounts[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + typeCounts[0].descriptorCount = descriptorCount; + // For additional types you need to add new entries in the type count list + // E.g. for two combined image samplers : + // typeCounts[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + // typeCounts[1].descriptorCount = 2; + + // Create the global descriptor pool + // All descriptors used in this example are allocated from this pool + VkDescriptorPoolCreateInfo descriptorPoolInfo = {}; + descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + descriptorPoolInfo.pNext = nullptr; + descriptorPoolInfo.poolSizeCount = 1; + descriptorPoolInfo.pPoolSizes = typeCounts; + // Set the max. number of descriptor sets that can be requested from this pool (requesting beyond this limit will result in an error) + descriptorPoolInfo.maxSets = descriptorCount; + + VkDescriptorPool result; + + + if (logicalDevice->functions().vkCreateDescriptorPool(&descriptorPoolInfo, nullptr, &result) != VK_SUCCESS) + { + throw std::runtime_error("Failed to create descriptor pool"); + } + return result; +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/Application.h b/Src/RenderFramework/Vulkan/Application.h new file mode 100644 index 0000000..4435ca2 --- /dev/null +++ b/Src/RenderFramework/Vulkan/Application.h @@ -0,0 +1,88 @@ +#pragma once + +#include + +#include +#include +#include "DynamicLibrary.h" +#include "VulkanInstance.h" +#include "VulkanDynamicLibrary.h" +#include "VulkanLogicalDevice.h" +#include "VulkanImageView.h" +#include "VulkanSwapChain.h" +#include "VulkanImageView.h" +#include "VulkanShaderModule.h" +#include "VulkanSemaphore.h" +#include "VulkanDescriptorSetLayout.h" +#include "VulkanMemory.h" +#include "VulkanBuffer.h" +#include "VulkanPipeline.h" +#include "VulkanFrameBuffer.h" +#include "UboPerObjectData.h" +#include "RenderWindow.h" +#include "TempFile.h" +#include "ShaderCompiler.h" +#include +#include +#include +#include "Vertex.h" +#include "UniformBuffer.h" +#include + + +#define DEFAULT_FENCE_TIMEOUT 100000000000 + +class Application { +public: + Application(); + + void createSwapChain(); + + void run(); + + void copyBufferHostToDevice(IntrusivePtr device, VulkanQueue queue, VkCommandPool pool, IntrusivePtr hostBuffer, IntrusivePtr deviceBuffer); + + IntrusivePtr createBuffer(VkBufferUsageFlagBits usage, const void* data, VkDeviceSize size, IntrusivePtr logicalDevice, IntrusivePtr device, VulkanQueue queue, VkCommandPool commandPool); + + VkDescriptorPool createDescriptorPool(std::size_t descriptorCount); + + void createPipeline(); + + void recordCommandBuffer(VkCommandBuffer cmdBuffer, uint32_t cmdBufferIndex, uint32_t imageIndex); + + void updateUniformBuffer(uint32_t currentImage); +private: + std::shared_ptr vulkan; + IntrusivePtr device; + IntrusivePtr logicalDevice; + std::vector queues; + VulkanSwapChain* swapChain; + RenderWindow* window; + VkCommandPool presentCommandPool; + VkCommandPool renderCommandPool; + uint32_t presentQueueFamilyIndex = -1; + uint32_t renderQueueFamilyIndex = -1; + + IntrusivePtr vs; + IntrusivePtr ps; + + IntrusivePtr _vertexBuffer; + IntrusivePtr _indexBuffer; + + IntrusivePtr _pipeline; + + std::vector> _frameBuffers; + std::vector> _imageViews; + std::vector> _uniformBuffers; + + IntrusivePtr _uboDescriptorSetLayout; + + std::vector descriptorSets; + + VkRenderPass _renderPass; + + std::vector presentCommandBuffers; + std::vector _cmdBufferFences; + + void compileShaders(); +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/CMakeLists.txt b/Src/RenderFramework/Vulkan/CMakeLists.txt new file mode 100644 index 0000000..2219f7f --- /dev/null +++ b/Src/RenderFramework/Vulkan/CMakeLists.txt @@ -0,0 +1,86 @@ + + +include(VulkanTools) + +Vulkan_generateFunctionsFile("${CMAKE_CURRENT_LIST_DIR}") + +add_library(VulkanWrapper INTERFACE) + +target_compile_definitions(VulkanWrapper +INTERFACE + VK_NO_PROTOTYPES +) + +target_sources(VulkanWrapper +INTERFACE + Application.cpp + Application.h + CMakeLists.txt + DynamicLibrary.cpp + DynamicLibrary.h + FragmentShader_unknown.h + FunctionTraits.h + IntrusivePtr.h + main.cpp + RefCountedObject.h + RenderWindow.h + RenderWindowWindows.cpp + ShaderCompiler.h + TempFile.h + VertexShader_unknown.h + VulkanApplicationInfo.h + VulkanBuffer.h + VulkanCommon.h + VulkanDynamicLibrary.h + VulkanFunctions.h + VulkanImageView.h + VulkanInstance.cpp + VulkanInstance.h + VulkanLibrary.cpp + VulkanLibrary.h + VulkanLogicalDevice.cpp + VulkanLogicalDevice.h + VulkanMemory.h + VulkanMemoryProperties.h + VulkanPhysicalDevice.cpp + VulkanPhysicalDevice.h + VulkanQueueFamilyProperties.h + VulkanSemaphore.h + VulkanShaderModule.h + VulkanSwapChain.h + WindowWindows.h + + VulkanDeviceFunctions.h + VulkanInstanceFunctions.h + VulkanGlobalFunctions.h + + Vertex.h + VulkanPipelineLayout.h + VulkanPipelineLayout.cpp + + VulkanPipeline.h + VulkanPipeline.cpp + + VulkanFrameBuffer.h + VulkanFrameBuffer.cpp + + VulkanDescriptorSetLayout.h + VulkanDescriptorSetLayout.cpp + UboPerObjectData.h + + UniformBuffer.h + + ${Vulkan_INCLUDE_DIR}/../Source/SPIRV-Reflect/spirv_reflect.h + ${Vulkan_INCLUDE_DIR}/../Source/SPIRV-Reflect/spirv_reflect.c +) + +target_include_directories(VulkanWrapper +INTERFACE + ${Vulkan_INCLUDE_DIR}/../Source/SPIRV-Reflect +) + +target_link_libraries(VulkanWrapper +INTERFACE + Vulkan::Vulkan + glslang::glslang +) \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/DynamicLibrary.cpp b/Src/RenderFramework/Vulkan/DynamicLibrary.cpp new file mode 100644 index 0000000..b569fb6 --- /dev/null +++ b/Src/RenderFramework/Vulkan/DynamicLibrary.cpp @@ -0,0 +1,18 @@ +#include "DynamicLibrary.h" + + +DynamicLibrary::DynamicLibrary(const std::filesystem::path& path) { + _library = LoadLibraryW(path.c_str()); + + if (_library == NULL) { + throw std::runtime_error("Failed to load library"); + } +} + +void DynamicLibrary::addSearchPath(const std::filesystem::path& path) { + SetDllDirectoryW(path.c_str()); +} + +void* DynamicLibrary::getFunction(const std::string& name) { + return GetProcAddress(_library, name.c_str()); +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/DynamicLibrary.h b/Src/RenderFramework/Vulkan/DynamicLibrary.h new file mode 100644 index 0000000..6ca747d --- /dev/null +++ b/Src/RenderFramework/Vulkan/DynamicLibrary.h @@ -0,0 +1,21 @@ +#pragma once + +#include +#include +#include +#include + +class DynamicLibrary { +public: + DynamicLibrary(const std::filesystem::path& path); + static void addSearchPath(const std::filesystem::path& path); + + template>>> + FunctionPtr getFunction(const std::string& name) { + return reinterpret_cast(getFunction(name)); + } + + void* getFunction(const std::string& name); +private: + HMODULE _library = NULL; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/FragmentShader_unknown.h b/Src/RenderFramework/Vulkan/FragmentShader_unknown.h new file mode 100644 index 0000000..ec417c8 --- /dev/null +++ b/Src/RenderFramework/Vulkan/FragmentShader_unknown.h @@ -0,0 +1,14 @@ +#pragma once + +const char* frag = R"( + #version 450 + #extension GL_ARB_separate_shader_objects : enable + + layout(location = 0) in vec3 fragColor; + + layout(location = 0) out vec4 outColor; + + void main() { + outColor = vec4(fragColor, 1.0); + } +)"; diff --git a/Src/RenderFramework/Vulkan/FunctionTraits.h b/Src/RenderFramework/Vulkan/FunctionTraits.h new file mode 100644 index 0000000..50cdf3b --- /dev/null +++ b/Src/RenderFramework/Vulkan/FunctionTraits.h @@ -0,0 +1,76 @@ +#pragma once +#include + +template +struct FunctionTraits; + +template +struct FunctionTraits +{ + using ReturnType = R; + + static constexpr std::size_t Arity = sizeof...(Args); + + using AllArgs = std::tuple; + + template + struct ArgumentHelper + { + static_assert(N < Arity, "error: invalid parameter index."); + using Type = typename std::tuple_element>::type; + }; + + template + using Argument = typename ArgumentHelper::Type; +}; + +// function pointer +template +struct FunctionTraits : public FunctionTraits +{}; + + +template +struct RemoveFirstType +{ +}; + +template +struct RemoveFirstType> +{ + typedef std::tuple type; +}; + +template +struct RemoveFirstArg {}; + +template +struct RemoveFirstArg { + + template + struct TypeHelper { + using type = TResult1(*)(TArgs1...); + }; + using pointerType = typename TypeHelper::type; + using type = std::remove_pointer_t; +}; + +template +struct RemoveFirstArg : RemoveFirstArg {}; + +template +using RemoveFirstArgT = typename RemoveFirstArg::type; + + +template +struct LambdaHelper {}; + +template +struct LambdaHelper { + using RawFunc = R(*)(VkDevice, Args...); + static auto makeLambda(RawFunc func, VkDevice device) { + return [func, device](Args... args) { + return func(device, args...); + }; + } +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/IntrusivePtr.h b/Src/RenderFramework/Vulkan/IntrusivePtr.h new file mode 100644 index 0000000..4a78e7b --- /dev/null +++ b/Src/RenderFramework/Vulkan/IntrusivePtr.h @@ -0,0 +1,104 @@ +#pragma once +#include +#include + +template +void IntrusivePtrAddRef(T* ptr) { + ptr->addref(); +} + +template +void IntrusivePtrRelease(T* ptr) { + ptr->release(); +} + +template +class IntrusivePtr { +public: + IntrusivePtr() { + } + ~IntrusivePtr() { + reset(); + } + + template + IntrusivePtr(U* src, bool addref = true) : _object(static_cast, Object>>>(src)) { + if (addref) { + addrefImpl(); + } + } + + template + IntrusivePtr(const IntrusivePtr& src) : _object(static_cast, Object>>>(src.get())) { + addrefImpl(); + } + + IntrusivePtr(Object* object, bool addref = true) :_object(object) { + if (addref) { + addrefImpl(); + } + } + IntrusivePtr(const IntrusivePtr& ptr) { + _object = ptr._object; + if (_object) { + addrefImpl(); + } + } + IntrusivePtr& operator=(const IntrusivePtr& other) { + assign(other._object, true); + return *this; + } + IntrusivePtr& operator=(std::nullptr_t) { + reset(); + return *this; + } + + template + static inline IntrusivePtr create(Args... args){ + return IntrusivePtr( new Object(std::forward(args)... )); + } + + void assign(Object* object, bool addref = true) { + if (object != nullptr && addref) { + object->addref(); + } + reset(); + _object = object; + } + + Object* operator->() { + if (_object == nullptr) { + throw new std::runtime_error("Accessing null object in IntrusivePtr"); + } + return _object; + } + + const Object* operator->() const { + if (_object == nullptr) { + throw new std::runtime_error("Accessing null object in IntrusivePtr"); + } + return _object; + } + + void reset() { + if (_object != nullptr) { + releaseImpl(); + _object = nullptr; + } + } + + Object* get() const { + return _object; + } + +private: + Object * _object = nullptr; + + void addrefImpl() { + IntrusivePtrAddRef(_object); + } + + void releaseImpl() { + IntrusivePtrRelease(_object); + } +}; diff --git a/Src/RenderFramework/Vulkan/RefCountedObject.h b/Src/RenderFramework/Vulkan/RefCountedObject.h new file mode 100644 index 0000000..f0e5a77 --- /dev/null +++ b/Src/RenderFramework/Vulkan/RefCountedObject.h @@ -0,0 +1,18 @@ +#pragma once + +#include "IntrusivePtr.h" + +class RefCountedObject { +public: + virtual ~RefCountedObject() = default; + void addref() { + ++_refCount; + } + void release() { + if (--_refCount == 0) { + delete this; + } + } +private: + size_t _refCount = 0; +}; diff --git a/Src/RenderFramework/Vulkan/RenderWindow.h b/Src/RenderFramework/Vulkan/RenderWindow.h new file mode 100644 index 0000000..803588c --- /dev/null +++ b/Src/RenderFramework/Vulkan/RenderWindow.h @@ -0,0 +1,19 @@ +#pragma once + +#include "VulkanInstance.h" +#include "IntrusivePtr.h" +#include + +class RenderWindow { +public: + RenderWindow(IntrusivePtr instance); + RenderWindow(IntrusivePtr instance, const std::string& name); + ~RenderWindow(); + static std::vector getRequiredExtensionNames(); + bool update(); + bool canPresent(IntrusivePtr physicalDevice, uint32_t queueFamilyIndex); + VkSurfaceKHR getSurface() const; +private: + class RenderWindowPrivate; + std::unique_ptr _private{}; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/RenderWindowWindows.cpp b/Src/RenderFramework/Vulkan/RenderWindowWindows.cpp new file mode 100644 index 0000000..da1fe6f --- /dev/null +++ b/Src/RenderFramework/Vulkan/RenderWindowWindows.cpp @@ -0,0 +1,59 @@ +#include "RenderWindow.h" +#include "WindowWindows.h" +#include +#include + +class RenderWindow::RenderWindowPrivate { +public: + RenderWindowPrivate(IntrusivePtr instance, const std::string& name):instance(instance) { + window = std::make_unique(name); + } + + ~RenderWindowPrivate() { + auto destroySurfaceKHR = instance->getProcAddr("vkDestroySurfaceKHR"); + if (destroySurfaceKHR) { + destroySurfaceKHR(instance->vkInstance(), surface, nullptr); + } + } + std::unique_ptr window{}; + VkSurfaceKHR surface; + IntrusivePtr instance; +}; + +RenderWindow::RenderWindow(IntrusivePtr instance) : RenderWindow(instance, "RenderWindow") {} +RenderWindow::RenderWindow(IntrusivePtr instance, const std::string& name) { + _private.reset(new RenderWindowPrivate(instance, name)); + + VkWin32SurfaceCreateInfoKHR createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; + createInfo.hwnd = _private->window->getHwnd(); + createInfo.hinstance = GetModuleHandle(nullptr); + + auto createWin32SurfaceKHR = instance->getProcAddr("vkCreateWin32SurfaceKHR"); + + if (!createWin32SurfaceKHR || createWin32SurfaceKHR(instance->vkInstance(), &createInfo, nullptr, &_private->surface) != VK_SUCCESS) { + throw std::runtime_error("Failed to create render window surface"); + } +} +RenderWindow::~RenderWindow() = default; + +std::vector RenderWindow::getRequiredExtensionNames(){ + return { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME }; +} + +bool RenderWindow::update() { + return _private->window->update(); +} + +bool RenderWindow::canPresent(IntrusivePtr physicalDevice, uint32_t queueFamilyIndex) { + auto func = _private->instance->getProcAddr("vkGetPhysicalDeviceSurfaceSupportKHR"); + if (func == nullptr) { + return false; + } + VkBool32 presentSupported = VK_FALSE; + func(physicalDevice->getDevice(), queueFamilyIndex, _private->surface, &presentSupported); + return presentSupported != VK_FALSE; +} +VkSurfaceKHR RenderWindow::getSurface() const { + return _private->surface; +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/ShaderCompiler.h b/Src/RenderFramework/Vulkan/ShaderCompiler.h new file mode 100644 index 0000000..90531a5 --- /dev/null +++ b/Src/RenderFramework/Vulkan/ShaderCompiler.h @@ -0,0 +1,82 @@ +#pragma once + +#include +#include +#include "TempFile.h" +#include + +enum class ShaderCompilerStage { + vert, + tesc, + tese, + geom, + frag, + comp +}; + +inline const char* toString(ShaderCompilerStage stage) { + switch (stage) { + case ShaderCompilerStage::vert: + return "vert"; + case ShaderCompilerStage::tesc: + return "tesc"; + case ShaderCompilerStage::tese: + return "tese"; + case ShaderCompilerStage::geom: + return "geom"; + case ShaderCompilerStage::frag: + return "frag"; + case ShaderCompilerStage::comp: + return "comp"; + default: + throw std::runtime_error("Unknown ShaderCompilerStage"); + } + +} + +struct ShaderCompilerResult { + bool success; + std::string errors; + std::vector binary; +}; + +class ShaderCompiler { +public: + static ShaderCompilerResult compile(const std::string& code, ShaderCompilerStage stage) { + ShaderCompilerResult result; + auto inputFile = TempFile(); + inputFile.open(); + inputFile << code; + inputFile.close(); + + auto outputVertexFile = TempFile(); + + auto errorFile = TempFile(); + + std::string compilerPath = R"(C:\VulkanSDK\1.3.290.0\Bin\glslangValidator.exe)"; + + if (!std::filesystem::exists(compilerPath)) { + throw new std::runtime_error("Failed to find shader compiler at path: " + compilerPath); + } + + std::string cmd = compilerPath + " -V "; + cmd += inputFile.path() + " -o " + outputVertexFile.path() + " -S " + toString(stage) + " >" + errorFile.path(); + + int errorCode = std::system(cmd.c_str()); + errorFile.open(std::ios_base::in | std::ios_base::binary); + auto errorData = errorFile.readAll(); + std::string error(errorData.data(), errorData.size()); + result.errors = error; + + result.success = errorCode == 0; + + if(!result.success){ + std::cout << result.errors << std::endl; + throw std::runtime_error("Failed to compile shader"); + } + + outputVertexFile.open(std::ios_base::in | std::ios_base::binary); + result.binary = outputVertexFile.readAll(); + return result; + } +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/TempFile.h b/Src/RenderFramework/Vulkan/TempFile.h new file mode 100644 index 0000000..6280689 --- /dev/null +++ b/Src/RenderFramework/Vulkan/TempFile.h @@ -0,0 +1,72 @@ +#pragma once + +#include +#include +#include +#include + +class TempFile { +public: + TempFile() { + std::vector path; + path.resize(MAX_PATH); + GetTempPathA(path.size(), path.data()); + + std::vector name; + name.resize(MAX_PATH); + GetTempFileNameA(path.data(), "vk", 0, name.data()); + _path = name.data(); + } + + std::fstream& open(std::ios_base::openmode mode = std::ios_base::out | std::ios_base::in | std::ios_base::binary) { + _stream.open(_path, mode); + return _stream; + } + + void close() { + _stream.close(); + } + + std::vector readAll() { + _stream.seekg(0, std::ios::end); + auto pos = _stream.tellg(); + _stream.seekg(0, std::ios::beg); + + std::vector result(pos); + + if (pos > 0) { + _stream.read(&result[0], pos); + } + + return result; + } + + template + TempFile& operator <<(const T& value) { + _stream << value; + return *this; + } + + template + TempFile& operator >>(T& value) { + _stream >> value; + return *this; + } + + ~TempFile() { + if (_stream.is_open()) { + _stream.close(); + } + DeleteFileA(_path.data()); + } + const std::string& path() const { + return _path; + } + + std::fstream& stream() { + return _stream; + } +private: + std::fstream _stream; + std::string _path; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/UboPerObjectData.h b/Src/RenderFramework/Vulkan/UboPerObjectData.h new file mode 100644 index 0000000..ed63d10 --- /dev/null +++ b/Src/RenderFramework/Vulkan/UboPerObjectData.h @@ -0,0 +1,7 @@ +#include + +struct UboPerObjectData { + glm::mat4 model; + glm::mat4 view; + glm::mat4 proj; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/UniformBuffer.h b/Src/RenderFramework/Vulkan/UniformBuffer.h new file mode 100644 index 0000000..3261fd2 --- /dev/null +++ b/Src/RenderFramework/Vulkan/UniformBuffer.h @@ -0,0 +1,27 @@ +#pragma once + +#include "VulkanBuffer.h" +#include "VulkanLogicalDevice.h" +#include "RefCountedObject.h" + +class UniformBuffer : public RefCountedObject { +public: + UniformBuffer(IntrusivePtr device, std::size_t dataSize) { + _buffer = IntrusivePtr(new VulkanBuffer(device, dataSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)); + _buffer->allocateMemory(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + auto memory = _buffer->memory(); + _mappedMemory = memory->map(dataSize, 0); + } + IntrusivePtr buffer() { + return _buffer; + } + void* mappedMemory() const { + return _mappedMemory; + } + ~UniformBuffer() { + _buffer->memory()->unmap(); + } +private: + void* _mappedMemory; + IntrusivePtr _buffer; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/Vertex.h b/Src/RenderFramework/Vulkan/Vertex.h new file mode 100644 index 0000000..33025ca --- /dev/null +++ b/Src/RenderFramework/Vulkan/Vertex.h @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +struct Vertex { + float position[3]; + float color[3]; + + static VkVertexInputBindingDescription getBindingDescription(uint32_t bindingId = 0) { + VkVertexInputBindingDescription bindingDescription{}; + bindingDescription.binding = bindingId; + bindingDescription.stride = sizeof(Vertex); + bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + return bindingDescription; + } + + static std::array getAttributeDescriptions(uint32_t bindingId = 0) { + std::array attributeDescriptions{}; + attributeDescriptions[0].binding = bindingId; + attributeDescriptions[0].location = 0; + attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT; + attributeDescriptions[0].offset = offsetof(Vertex, position); + + + attributeDescriptions[1].binding = bindingId; + attributeDescriptions[1].location = 1; + attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT; + attributeDescriptions[1].offset = offsetof(Vertex, color); + + return attributeDescriptions; + } +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VertexShader_unknown.h b/Src/RenderFramework/Vulkan/VertexShader_unknown.h new file mode 100644 index 0000000..abc6333 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VertexShader_unknown.h @@ -0,0 +1,22 @@ +#pragma once + +const char* vert = R"( + #version 450 + #extension GL_ARB_separate_shader_objects : enable + + layout(binding = 0) uniform UniformBufferObject { + mat4 model; + mat4 view; + mat4 proj; + } ubo; + + layout(location = 0) in vec3 inPosition; + layout(location = 1) in vec3 inColor; + + layout(location = 0) out vec3 fragColor; + + void main() { + gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition.xyz, 1.0); + fragColor = vec3(inColor.xyz); + } +)"; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanApplicationInfo.h b/Src/RenderFramework/Vulkan/VulkanApplicationInfo.h new file mode 100644 index 0000000..7d997cc --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanApplicationInfo.h @@ -0,0 +1,15 @@ +#pragma once + +#include + +struct VulkanApplicationInfo : public VkApplicationInfo { + VulkanApplicationInfo(const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0) { + sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + pNext = nullptr; + pApplicationName = pApplicationName_; + applicationVersion = applicationVersion_; + pEngineName = pEngineName_; + engineVersion = engineVersion_; + apiVersion = apiVersion_; + } +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanBuffer.h b/Src/RenderFramework/Vulkan/VulkanBuffer.h new file mode 100644 index 0000000..7cee08e --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanBuffer.h @@ -0,0 +1,82 @@ +#pragma once + +#include +#include "VulkanLogicalDevice.h" +#include "VulkanMemory.h" +#include "IntrusivePtr.h" + +class VulkanBuffer : public RefCountedObject { +public: + VulkanBuffer(IntrusivePtr device, VkBufferCreateInfo createInfo):_device(device) { + internalConstruct(createInfo); + } + + VulkanBuffer(const VulkanBuffer&) = delete; + + VulkanBuffer(VulkanBuffer&& other) noexcept { + _buffer = other._buffer; + _size = other._size; + _device = other._device; + _memory = other._memory; + + other._buffer = nullptr; + other._size = 0; + other._device = nullptr; + other._memory = nullptr; + } + + VulkanBuffer(IntrusivePtr device, VkDeviceSize size, VkBufferUsageFlags usageFlags) : _device(device) { + VkBufferCreateInfo createInfo{}; + createInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + createInfo.size = size; + createInfo.usage = usageFlags; + internalConstruct(createInfo); + } + + VkMemoryRequirements getMemoryRequirements() { + VkMemoryRequirements result; + _device->functions().vkGetBufferMemoryRequirements(_buffer, &result); + return result; + } + + void bindMemory(IntrusivePtr memory) { + _memory = memory; + if (_device->functions().vkBindBufferMemory(_buffer, _memory->native(), 0) != VK_SUCCESS) { + throw std::runtime_error("Failed to bind memory to vulkan buffer"); + } + } + + void allocateMemory(VkMemoryPropertyFlags flags) { + auto memoryProps = _device->physicalDevice()->getMemoryProperties(); + auto memoryRequirements = getMemoryRequirements(); + auto suitableIndices = memoryProps.findSuitableMemoryTypeIndices(flags, memoryRequirements.memoryTypeBits); + auto memory = IntrusivePtr(new VulkanMemory(_device, memoryRequirements.size, suitableIndices[0])); + bindMemory(memory); + } + + VkBuffer native() const { + return _buffer; + } + VkDeviceSize size() const { + return _size; + } + IntrusivePtr memory() { + return _memory; + } + ~VulkanBuffer() { + if (_buffer != nullptr) { + _device->functions().vkDestroyBuffer(_buffer, nullptr); + } + } +private: + void internalConstruct( VkBufferCreateInfo createInfo) { + if (_device->functions().vkCreateBuffer(&createInfo, nullptr, &_buffer) != VK_SUCCESS) { + throw std::runtime_error("Failed to create vulkan buffer"); + } + _size = createInfo.size; + } + VkBuffer _buffer = {}; + VkDeviceSize _size; + IntrusivePtr _device; + IntrusivePtr _memory; +}; diff --git a/Src/RenderFramework/Vulkan/VulkanCommon.h b/Src/RenderFramework/Vulkan/VulkanCommon.h new file mode 100644 index 0000000..a5728d9 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanCommon.h @@ -0,0 +1,6 @@ +#pragma once + +#include + +template +using VulkanPtr = std::shared_ptr; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.cpp b/Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.cpp new file mode 100644 index 0000000..6f227cb --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.cpp @@ -0,0 +1,16 @@ +#include "VulkanDescriptorSetLayout.h" +#include "VulkanLogicalDevice.h" + +VulkanDescriptorSetLayout::VulkanDescriptorSetLayout(IntrusivePtr device, const VkDescriptorSetLayoutCreateInfo& createInfo):_device(device){ + if (device->functions().vkCreateDescriptorSetLayout(&createInfo, nullptr, &_native) != VK_SUCCESS) { + throw std::runtime_error("failed to create descriptor set layout!"); + } +} +VulkanDescriptorSetLayout::VulkanDescriptorSetLayout(IntrusivePtr device, VkDescriptorSetLayout native):_device(device), _native(native){ + +} +VulkanDescriptorSetLayout::~VulkanDescriptorSetLayout(){ + if(_native != nullptr){ + _device->functions().vkDestroyDescriptorSetLayout(_native, nullptr); + } +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.h b/Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.h new file mode 100644 index 0000000..a4814dd --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.h @@ -0,0 +1,21 @@ +#pragma once + +#include "IntrusivePtr.h" +#include "RefCountedObject.h" +#include + +class VulkanLogicalDevice; + +class VulkanDescriptorSetLayout : public RefCountedObject { +public: + VulkanDescriptorSetLayout(IntrusivePtr device, const VkDescriptorSetLayoutCreateInfo& createInfo); + VulkanDescriptorSetLayout(IntrusivePtr device, VkDescriptorSetLayout native); + VkDescriptorSetLayout native() const { + return _native; + + } + ~VulkanDescriptorSetLayout(); +private: + IntrusivePtr _device; + VkDescriptorSetLayout _native; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanDeviceFunctions.h b/Src/RenderFramework/Vulkan/VulkanDeviceFunctions.h new file mode 100644 index 0000000..350a648 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanDeviceFunctions.h @@ -0,0 +1,2714 @@ +#pragma once +#include +#include +class VulkanDeviceFunctions { +public: + VulkanDeviceFunctions(std::function loader, VkDevice device) : _device(device){ + _vkDestroyDevice = reinterpret_cast(loader("vkDestroyDevice")); + _vkGetDeviceQueue = reinterpret_cast(loader("vkGetDeviceQueue")); + _vkQueueSubmit = reinterpret_cast(loader("vkQueueSubmit")); + _vkQueueWaitIdle = reinterpret_cast(loader("vkQueueWaitIdle")); + _vkDeviceWaitIdle = reinterpret_cast(loader("vkDeviceWaitIdle")); + _vkAllocateMemory = reinterpret_cast(loader("vkAllocateMemory")); + _vkFreeMemory = reinterpret_cast(loader("vkFreeMemory")); + _vkMapMemory = reinterpret_cast(loader("vkMapMemory")); + _vkUnmapMemory = reinterpret_cast(loader("vkUnmapMemory")); + _vkFlushMappedMemoryRanges = reinterpret_cast(loader("vkFlushMappedMemoryRanges")); + _vkInvalidateMappedMemoryRanges = reinterpret_cast(loader("vkInvalidateMappedMemoryRanges")); + _vkGetDeviceMemoryCommitment = reinterpret_cast(loader("vkGetDeviceMemoryCommitment")); + _vkBindBufferMemory = reinterpret_cast(loader("vkBindBufferMemory")); + _vkBindImageMemory = reinterpret_cast(loader("vkBindImageMemory")); + _vkGetBufferMemoryRequirements = reinterpret_cast(loader("vkGetBufferMemoryRequirements")); + _vkGetImageMemoryRequirements = reinterpret_cast(loader("vkGetImageMemoryRequirements")); + _vkGetImageSparseMemoryRequirements = reinterpret_cast(loader("vkGetImageSparseMemoryRequirements")); + _vkQueueBindSparse = reinterpret_cast(loader("vkQueueBindSparse")); + _vkCreateFence = reinterpret_cast(loader("vkCreateFence")); + _vkDestroyFence = reinterpret_cast(loader("vkDestroyFence")); + _vkResetFences = reinterpret_cast(loader("vkResetFences")); + _vkGetFenceStatus = reinterpret_cast(loader("vkGetFenceStatus")); + _vkWaitForFences = reinterpret_cast(loader("vkWaitForFences")); + _vkCreateSemaphore = reinterpret_cast(loader("vkCreateSemaphore")); + _vkDestroySemaphore = reinterpret_cast(loader("vkDestroySemaphore")); + _vkCreateEvent = reinterpret_cast(loader("vkCreateEvent")); + _vkDestroyEvent = reinterpret_cast(loader("vkDestroyEvent")); + _vkGetEventStatus = reinterpret_cast(loader("vkGetEventStatus")); + _vkSetEvent = reinterpret_cast(loader("vkSetEvent")); + _vkResetEvent = reinterpret_cast(loader("vkResetEvent")); + _vkCreateQueryPool = reinterpret_cast(loader("vkCreateQueryPool")); + _vkDestroyQueryPool = reinterpret_cast(loader("vkDestroyQueryPool")); + _vkGetQueryPoolResults = reinterpret_cast(loader("vkGetQueryPoolResults")); + _vkCreateBuffer = reinterpret_cast(loader("vkCreateBuffer")); + _vkDestroyBuffer = reinterpret_cast(loader("vkDestroyBuffer")); + _vkCreateBufferView = reinterpret_cast(loader("vkCreateBufferView")); + _vkDestroyBufferView = reinterpret_cast(loader("vkDestroyBufferView")); + _vkCreateImage = reinterpret_cast(loader("vkCreateImage")); + _vkDestroyImage = reinterpret_cast(loader("vkDestroyImage")); + _vkGetImageSubresourceLayout = reinterpret_cast(loader("vkGetImageSubresourceLayout")); + _vkCreateImageView = reinterpret_cast(loader("vkCreateImageView")); + _vkDestroyImageView = reinterpret_cast(loader("vkDestroyImageView")); + _vkCreateShaderModule = reinterpret_cast(loader("vkCreateShaderModule")); + _vkDestroyShaderModule = reinterpret_cast(loader("vkDestroyShaderModule")); + _vkCreatePipelineCache = reinterpret_cast(loader("vkCreatePipelineCache")); + _vkDestroyPipelineCache = reinterpret_cast(loader("vkDestroyPipelineCache")); + _vkGetPipelineCacheData = reinterpret_cast(loader("vkGetPipelineCacheData")); + _vkMergePipelineCaches = reinterpret_cast(loader("vkMergePipelineCaches")); + _vkCreateGraphicsPipelines = reinterpret_cast(loader("vkCreateGraphicsPipelines")); + _vkCreateComputePipelines = reinterpret_cast(loader("vkCreateComputePipelines")); + _vkDestroyPipeline = reinterpret_cast(loader("vkDestroyPipeline")); + _vkCreatePipelineLayout = reinterpret_cast(loader("vkCreatePipelineLayout")); + _vkDestroyPipelineLayout = reinterpret_cast(loader("vkDestroyPipelineLayout")); + _vkCreateSampler = reinterpret_cast(loader("vkCreateSampler")); + _vkDestroySampler = reinterpret_cast(loader("vkDestroySampler")); + _vkCreateDescriptorSetLayout = reinterpret_cast(loader("vkCreateDescriptorSetLayout")); + _vkDestroyDescriptorSetLayout = reinterpret_cast(loader("vkDestroyDescriptorSetLayout")); + _vkCreateDescriptorPool = reinterpret_cast(loader("vkCreateDescriptorPool")); + _vkDestroyDescriptorPool = reinterpret_cast(loader("vkDestroyDescriptorPool")); + _vkResetDescriptorPool = reinterpret_cast(loader("vkResetDescriptorPool")); + _vkAllocateDescriptorSets = reinterpret_cast(loader("vkAllocateDescriptorSets")); + _vkFreeDescriptorSets = reinterpret_cast(loader("vkFreeDescriptorSets")); + _vkUpdateDescriptorSets = reinterpret_cast(loader("vkUpdateDescriptorSets")); + _vkCreateFramebuffer = reinterpret_cast(loader("vkCreateFramebuffer")); + _vkDestroyFramebuffer = reinterpret_cast(loader("vkDestroyFramebuffer")); + _vkCreateRenderPass = reinterpret_cast(loader("vkCreateRenderPass")); + _vkDestroyRenderPass = reinterpret_cast(loader("vkDestroyRenderPass")); + _vkGetRenderAreaGranularity = reinterpret_cast(loader("vkGetRenderAreaGranularity")); + _vkCreateCommandPool = reinterpret_cast(loader("vkCreateCommandPool")); + _vkDestroyCommandPool = reinterpret_cast(loader("vkDestroyCommandPool")); + _vkResetCommandPool = reinterpret_cast(loader("vkResetCommandPool")); + _vkAllocateCommandBuffers = reinterpret_cast(loader("vkAllocateCommandBuffers")); + _vkFreeCommandBuffers = reinterpret_cast(loader("vkFreeCommandBuffers")); + _vkBeginCommandBuffer = reinterpret_cast(loader("vkBeginCommandBuffer")); + _vkEndCommandBuffer = reinterpret_cast(loader("vkEndCommandBuffer")); + _vkResetCommandBuffer = reinterpret_cast(loader("vkResetCommandBuffer")); + _vkCmdBindPipeline = reinterpret_cast(loader("vkCmdBindPipeline")); + _vkCmdSetViewport = reinterpret_cast(loader("vkCmdSetViewport")); + _vkCmdSetScissor = reinterpret_cast(loader("vkCmdSetScissor")); + _vkCmdSetLineWidth = reinterpret_cast(loader("vkCmdSetLineWidth")); + _vkCmdSetDepthBias = reinterpret_cast(loader("vkCmdSetDepthBias")); + _vkCmdSetBlendConstants = reinterpret_cast(loader("vkCmdSetBlendConstants")); + _vkCmdSetDepthBounds = reinterpret_cast(loader("vkCmdSetDepthBounds")); + _vkCmdSetStencilCompareMask = reinterpret_cast(loader("vkCmdSetStencilCompareMask")); + _vkCmdSetStencilWriteMask = reinterpret_cast(loader("vkCmdSetStencilWriteMask")); + _vkCmdSetStencilReference = reinterpret_cast(loader("vkCmdSetStencilReference")); + _vkCmdBindDescriptorSets = reinterpret_cast(loader("vkCmdBindDescriptorSets")); + _vkCmdBindIndexBuffer = reinterpret_cast(loader("vkCmdBindIndexBuffer")); + _vkCmdBindVertexBuffers = reinterpret_cast(loader("vkCmdBindVertexBuffers")); + _vkCmdDraw = reinterpret_cast(loader("vkCmdDraw")); + _vkCmdDrawIndexed = reinterpret_cast(loader("vkCmdDrawIndexed")); + _vkCmdDrawIndirect = reinterpret_cast(loader("vkCmdDrawIndirect")); + _vkCmdDrawIndexedIndirect = reinterpret_cast(loader("vkCmdDrawIndexedIndirect")); + _vkCmdDispatch = reinterpret_cast(loader("vkCmdDispatch")); + _vkCmdDispatchIndirect = reinterpret_cast(loader("vkCmdDispatchIndirect")); + _vkCmdCopyBuffer = reinterpret_cast(loader("vkCmdCopyBuffer")); + _vkCmdCopyImage = reinterpret_cast(loader("vkCmdCopyImage")); + _vkCmdBlitImage = reinterpret_cast(loader("vkCmdBlitImage")); + _vkCmdCopyBufferToImage = reinterpret_cast(loader("vkCmdCopyBufferToImage")); + _vkCmdCopyImageToBuffer = reinterpret_cast(loader("vkCmdCopyImageToBuffer")); + _vkCmdUpdateBuffer = reinterpret_cast(loader("vkCmdUpdateBuffer")); + _vkCmdFillBuffer = reinterpret_cast(loader("vkCmdFillBuffer")); + _vkCmdClearColorImage = reinterpret_cast(loader("vkCmdClearColorImage")); + _vkCmdClearDepthStencilImage = reinterpret_cast(loader("vkCmdClearDepthStencilImage")); + _vkCmdClearAttachments = reinterpret_cast(loader("vkCmdClearAttachments")); + _vkCmdResolveImage = reinterpret_cast(loader("vkCmdResolveImage")); + _vkCmdSetEvent = reinterpret_cast(loader("vkCmdSetEvent")); + _vkCmdResetEvent = reinterpret_cast(loader("vkCmdResetEvent")); + _vkCmdWaitEvents = reinterpret_cast(loader("vkCmdWaitEvents")); + _vkCmdPipelineBarrier = reinterpret_cast(loader("vkCmdPipelineBarrier")); + _vkCmdBeginQuery = reinterpret_cast(loader("vkCmdBeginQuery")); + _vkCmdEndQuery = reinterpret_cast(loader("vkCmdEndQuery")); + _vkCmdResetQueryPool = reinterpret_cast(loader("vkCmdResetQueryPool")); + _vkCmdWriteTimestamp = reinterpret_cast(loader("vkCmdWriteTimestamp")); + _vkCmdCopyQueryPoolResults = reinterpret_cast(loader("vkCmdCopyQueryPoolResults")); + _vkCmdPushConstants = reinterpret_cast(loader("vkCmdPushConstants")); + _vkCmdBeginRenderPass = reinterpret_cast(loader("vkCmdBeginRenderPass")); + _vkCmdNextSubpass = reinterpret_cast(loader("vkCmdNextSubpass")); + _vkCmdEndRenderPass = reinterpret_cast(loader("vkCmdEndRenderPass")); + _vkCmdExecuteCommands = reinterpret_cast(loader("vkCmdExecuteCommands")); + _vkBindBufferMemory2 = reinterpret_cast(loader("vkBindBufferMemory2")); + _vkBindImageMemory2 = reinterpret_cast(loader("vkBindImageMemory2")); + _vkGetDeviceGroupPeerMemoryFeatures = reinterpret_cast(loader("vkGetDeviceGroupPeerMemoryFeatures")); + _vkCmdSetDeviceMask = reinterpret_cast(loader("vkCmdSetDeviceMask")); + _vkCmdDispatchBase = reinterpret_cast(loader("vkCmdDispatchBase")); + _vkGetImageMemoryRequirements2 = reinterpret_cast(loader("vkGetImageMemoryRequirements2")); + _vkGetBufferMemoryRequirements2 = reinterpret_cast(loader("vkGetBufferMemoryRequirements2")); + _vkGetImageSparseMemoryRequirements2 = reinterpret_cast(loader("vkGetImageSparseMemoryRequirements2")); + _vkTrimCommandPool = reinterpret_cast(loader("vkTrimCommandPool")); + _vkGetDeviceQueue2 = reinterpret_cast(loader("vkGetDeviceQueue2")); + _vkCreateSamplerYcbcrConversion = reinterpret_cast(loader("vkCreateSamplerYcbcrConversion")); + _vkDestroySamplerYcbcrConversion = reinterpret_cast(loader("vkDestroySamplerYcbcrConversion")); + _vkCreateDescriptorUpdateTemplate = reinterpret_cast(loader("vkCreateDescriptorUpdateTemplate")); + _vkDestroyDescriptorUpdateTemplate = reinterpret_cast(loader("vkDestroyDescriptorUpdateTemplate")); + _vkUpdateDescriptorSetWithTemplate = reinterpret_cast(loader("vkUpdateDescriptorSetWithTemplate")); + _vkGetDescriptorSetLayoutSupport = reinterpret_cast(loader("vkGetDescriptorSetLayoutSupport")); + _vkCmdDrawIndirectCount = reinterpret_cast(loader("vkCmdDrawIndirectCount")); + _vkCmdDrawIndexedIndirectCount = reinterpret_cast(loader("vkCmdDrawIndexedIndirectCount")); + _vkCreateRenderPass2 = reinterpret_cast(loader("vkCreateRenderPass2")); + _vkCmdBeginRenderPass2 = reinterpret_cast(loader("vkCmdBeginRenderPass2")); + _vkCmdNextSubpass2 = reinterpret_cast(loader("vkCmdNextSubpass2")); + _vkCmdEndRenderPass2 = reinterpret_cast(loader("vkCmdEndRenderPass2")); + _vkResetQueryPool = reinterpret_cast(loader("vkResetQueryPool")); + _vkGetSemaphoreCounterValue = reinterpret_cast(loader("vkGetSemaphoreCounterValue")); + _vkWaitSemaphores = reinterpret_cast(loader("vkWaitSemaphores")); + _vkSignalSemaphore = reinterpret_cast(loader("vkSignalSemaphore")); + _vkGetBufferDeviceAddress = reinterpret_cast(loader("vkGetBufferDeviceAddress")); + _vkGetBufferOpaqueCaptureAddress = reinterpret_cast(loader("vkGetBufferOpaqueCaptureAddress")); + _vkGetDeviceMemoryOpaqueCaptureAddress = reinterpret_cast(loader("vkGetDeviceMemoryOpaqueCaptureAddress")); + _vkCreatePrivateDataSlot = reinterpret_cast(loader("vkCreatePrivateDataSlot")); + _vkDestroyPrivateDataSlot = reinterpret_cast(loader("vkDestroyPrivateDataSlot")); + _vkSetPrivateData = reinterpret_cast(loader("vkSetPrivateData")); + _vkGetPrivateData = reinterpret_cast(loader("vkGetPrivateData")); + _vkCmdSetEvent2 = reinterpret_cast(loader("vkCmdSetEvent2")); + _vkCmdResetEvent2 = reinterpret_cast(loader("vkCmdResetEvent2")); + _vkCmdWaitEvents2 = reinterpret_cast(loader("vkCmdWaitEvents2")); + _vkCmdPipelineBarrier2 = reinterpret_cast(loader("vkCmdPipelineBarrier2")); + _vkCmdWriteTimestamp2 = reinterpret_cast(loader("vkCmdWriteTimestamp2")); + _vkQueueSubmit2 = reinterpret_cast(loader("vkQueueSubmit2")); + _vkCmdCopyBuffer2 = reinterpret_cast(loader("vkCmdCopyBuffer2")); + _vkCmdCopyImage2 = reinterpret_cast(loader("vkCmdCopyImage2")); + _vkCmdCopyBufferToImage2 = reinterpret_cast(loader("vkCmdCopyBufferToImage2")); + _vkCmdCopyImageToBuffer2 = reinterpret_cast(loader("vkCmdCopyImageToBuffer2")); + _vkCmdBlitImage2 = reinterpret_cast(loader("vkCmdBlitImage2")); + _vkCmdResolveImage2 = reinterpret_cast(loader("vkCmdResolveImage2")); + _vkCmdBeginRendering = reinterpret_cast(loader("vkCmdBeginRendering")); + _vkCmdEndRendering = reinterpret_cast(loader("vkCmdEndRendering")); + _vkCmdSetCullMode = reinterpret_cast(loader("vkCmdSetCullMode")); + _vkCmdSetFrontFace = reinterpret_cast(loader("vkCmdSetFrontFace")); + _vkCmdSetPrimitiveTopology = reinterpret_cast(loader("vkCmdSetPrimitiveTopology")); + _vkCmdSetViewportWithCount = reinterpret_cast(loader("vkCmdSetViewportWithCount")); + _vkCmdSetScissorWithCount = reinterpret_cast(loader("vkCmdSetScissorWithCount")); + _vkCmdBindVertexBuffers2 = reinterpret_cast(loader("vkCmdBindVertexBuffers2")); + _vkCmdSetDepthTestEnable = reinterpret_cast(loader("vkCmdSetDepthTestEnable")); + _vkCmdSetDepthWriteEnable = reinterpret_cast(loader("vkCmdSetDepthWriteEnable")); + _vkCmdSetDepthCompareOp = reinterpret_cast(loader("vkCmdSetDepthCompareOp")); + _vkCmdSetDepthBoundsTestEnable = reinterpret_cast(loader("vkCmdSetDepthBoundsTestEnable")); + _vkCmdSetStencilTestEnable = reinterpret_cast(loader("vkCmdSetStencilTestEnable")); + _vkCmdSetStencilOp = reinterpret_cast(loader("vkCmdSetStencilOp")); + _vkCmdSetRasterizerDiscardEnable = reinterpret_cast(loader("vkCmdSetRasterizerDiscardEnable")); + _vkCmdSetDepthBiasEnable = reinterpret_cast(loader("vkCmdSetDepthBiasEnable")); + _vkCmdSetPrimitiveRestartEnable = reinterpret_cast(loader("vkCmdSetPrimitiveRestartEnable")); + _vkGetDeviceBufferMemoryRequirements = reinterpret_cast(loader("vkGetDeviceBufferMemoryRequirements")); + _vkGetDeviceImageMemoryRequirements = reinterpret_cast(loader("vkGetDeviceImageMemoryRequirements")); + _vkGetDeviceImageSparseMemoryRequirements = reinterpret_cast(loader("vkGetDeviceImageSparseMemoryRequirements")); + _vkCreateSwapchainKHR = reinterpret_cast(loader("vkCreateSwapchainKHR")); + _vkDestroySwapchainKHR = reinterpret_cast(loader("vkDestroySwapchainKHR")); + _vkGetSwapchainImagesKHR = reinterpret_cast(loader("vkGetSwapchainImagesKHR")); + _vkAcquireNextImageKHR = reinterpret_cast(loader("vkAcquireNextImageKHR")); + _vkQueuePresentKHR = reinterpret_cast(loader("vkQueuePresentKHR")); + _vkGetDeviceGroupPresentCapabilitiesKHR = reinterpret_cast(loader("vkGetDeviceGroupPresentCapabilitiesKHR")); + _vkGetDeviceGroupSurfacePresentModesKHR = reinterpret_cast(loader("vkGetDeviceGroupSurfacePresentModesKHR")); + _vkAcquireNextImage2KHR = reinterpret_cast(loader("vkAcquireNextImage2KHR")); + _vkCreateSharedSwapchainsKHR = reinterpret_cast(loader("vkCreateSharedSwapchainsKHR")); + _vkCreateVideoSessionKHR = reinterpret_cast(loader("vkCreateVideoSessionKHR")); + _vkDestroyVideoSessionKHR = reinterpret_cast(loader("vkDestroyVideoSessionKHR")); + _vkGetVideoSessionMemoryRequirementsKHR = reinterpret_cast(loader("vkGetVideoSessionMemoryRequirementsKHR")); + _vkBindVideoSessionMemoryKHR = reinterpret_cast(loader("vkBindVideoSessionMemoryKHR")); + _vkCreateVideoSessionParametersKHR = reinterpret_cast(loader("vkCreateVideoSessionParametersKHR")); + _vkUpdateVideoSessionParametersKHR = reinterpret_cast(loader("vkUpdateVideoSessionParametersKHR")); + _vkDestroyVideoSessionParametersKHR = reinterpret_cast(loader("vkDestroyVideoSessionParametersKHR")); + _vkCmdBeginVideoCodingKHR = reinterpret_cast(loader("vkCmdBeginVideoCodingKHR")); + _vkCmdEndVideoCodingKHR = reinterpret_cast(loader("vkCmdEndVideoCodingKHR")); + _vkCmdControlVideoCodingKHR = reinterpret_cast(loader("vkCmdControlVideoCodingKHR")); + _vkCmdDecodeVideoKHR = reinterpret_cast(loader("vkCmdDecodeVideoKHR")); + _vkCmdBeginRenderingKHR = reinterpret_cast(loader("vkCmdBeginRenderingKHR")); + _vkCmdEndRenderingKHR = reinterpret_cast(loader("vkCmdEndRenderingKHR")); + _vkGetDeviceGroupPeerMemoryFeaturesKHR = reinterpret_cast(loader("vkGetDeviceGroupPeerMemoryFeaturesKHR")); + _vkCmdSetDeviceMaskKHR = reinterpret_cast(loader("vkCmdSetDeviceMaskKHR")); + _vkCmdDispatchBaseKHR = reinterpret_cast(loader("vkCmdDispatchBaseKHR")); + _vkTrimCommandPoolKHR = reinterpret_cast(loader("vkTrimCommandPoolKHR")); + _vkGetMemoryFdKHR = reinterpret_cast(loader("vkGetMemoryFdKHR")); + _vkGetMemoryFdPropertiesKHR = reinterpret_cast(loader("vkGetMemoryFdPropertiesKHR")); + _vkImportSemaphoreFdKHR = reinterpret_cast(loader("vkImportSemaphoreFdKHR")); + _vkGetSemaphoreFdKHR = reinterpret_cast(loader("vkGetSemaphoreFdKHR")); + _vkCmdPushDescriptorSetKHR = reinterpret_cast(loader("vkCmdPushDescriptorSetKHR")); + _vkCmdPushDescriptorSetWithTemplateKHR = reinterpret_cast(loader("vkCmdPushDescriptorSetWithTemplateKHR")); + _vkCreateDescriptorUpdateTemplateKHR = reinterpret_cast(loader("vkCreateDescriptorUpdateTemplateKHR")); + _vkDestroyDescriptorUpdateTemplateKHR = reinterpret_cast(loader("vkDestroyDescriptorUpdateTemplateKHR")); + _vkUpdateDescriptorSetWithTemplateKHR = reinterpret_cast(loader("vkUpdateDescriptorSetWithTemplateKHR")); + _vkCreateRenderPass2KHR = reinterpret_cast(loader("vkCreateRenderPass2KHR")); + _vkCmdBeginRenderPass2KHR = reinterpret_cast(loader("vkCmdBeginRenderPass2KHR")); + _vkCmdNextSubpass2KHR = reinterpret_cast(loader("vkCmdNextSubpass2KHR")); + _vkCmdEndRenderPass2KHR = reinterpret_cast(loader("vkCmdEndRenderPass2KHR")); + _vkGetSwapchainStatusKHR = reinterpret_cast(loader("vkGetSwapchainStatusKHR")); + _vkImportFenceFdKHR = reinterpret_cast(loader("vkImportFenceFdKHR")); + _vkGetFenceFdKHR = reinterpret_cast(loader("vkGetFenceFdKHR")); + _vkAcquireProfilingLockKHR = reinterpret_cast(loader("vkAcquireProfilingLockKHR")); + _vkReleaseProfilingLockKHR = reinterpret_cast(loader("vkReleaseProfilingLockKHR")); + _vkGetImageMemoryRequirements2KHR = reinterpret_cast(loader("vkGetImageMemoryRequirements2KHR")); + _vkGetBufferMemoryRequirements2KHR = reinterpret_cast(loader("vkGetBufferMemoryRequirements2KHR")); + _vkGetImageSparseMemoryRequirements2KHR = reinterpret_cast(loader("vkGetImageSparseMemoryRequirements2KHR")); + _vkCreateSamplerYcbcrConversionKHR = reinterpret_cast(loader("vkCreateSamplerYcbcrConversionKHR")); + _vkDestroySamplerYcbcrConversionKHR = reinterpret_cast(loader("vkDestroySamplerYcbcrConversionKHR")); + _vkBindBufferMemory2KHR = reinterpret_cast(loader("vkBindBufferMemory2KHR")); + _vkBindImageMemory2KHR = reinterpret_cast(loader("vkBindImageMemory2KHR")); + _vkGetDescriptorSetLayoutSupportKHR = reinterpret_cast(loader("vkGetDescriptorSetLayoutSupportKHR")); + _vkCmdDrawIndirectCountKHR = reinterpret_cast(loader("vkCmdDrawIndirectCountKHR")); + _vkCmdDrawIndexedIndirectCountKHR = reinterpret_cast(loader("vkCmdDrawIndexedIndirectCountKHR")); + _vkGetSemaphoreCounterValueKHR = reinterpret_cast(loader("vkGetSemaphoreCounterValueKHR")); + _vkWaitSemaphoresKHR = reinterpret_cast(loader("vkWaitSemaphoresKHR")); + _vkSignalSemaphoreKHR = reinterpret_cast(loader("vkSignalSemaphoreKHR")); + _vkCmdSetFragmentShadingRateKHR = reinterpret_cast(loader("vkCmdSetFragmentShadingRateKHR")); + _vkCmdSetRenderingAttachmentLocationsKHR = reinterpret_cast(loader("vkCmdSetRenderingAttachmentLocationsKHR")); + _vkCmdSetRenderingInputAttachmentIndicesKHR = reinterpret_cast(loader("vkCmdSetRenderingInputAttachmentIndicesKHR")); + _vkWaitForPresentKHR = reinterpret_cast(loader("vkWaitForPresentKHR")); + _vkGetBufferDeviceAddressKHR = reinterpret_cast(loader("vkGetBufferDeviceAddressKHR")); + _vkGetBufferOpaqueCaptureAddressKHR = reinterpret_cast(loader("vkGetBufferOpaqueCaptureAddressKHR")); + _vkGetDeviceMemoryOpaqueCaptureAddressKHR = reinterpret_cast(loader("vkGetDeviceMemoryOpaqueCaptureAddressKHR")); + _vkCreateDeferredOperationKHR = reinterpret_cast(loader("vkCreateDeferredOperationKHR")); + _vkDestroyDeferredOperationKHR = reinterpret_cast(loader("vkDestroyDeferredOperationKHR")); + _vkGetDeferredOperationMaxConcurrencyKHR = reinterpret_cast(loader("vkGetDeferredOperationMaxConcurrencyKHR")); + _vkGetDeferredOperationResultKHR = reinterpret_cast(loader("vkGetDeferredOperationResultKHR")); + _vkDeferredOperationJoinKHR = reinterpret_cast(loader("vkDeferredOperationJoinKHR")); + _vkGetPipelineExecutablePropertiesKHR = reinterpret_cast(loader("vkGetPipelineExecutablePropertiesKHR")); + _vkGetPipelineExecutableStatisticsKHR = reinterpret_cast(loader("vkGetPipelineExecutableStatisticsKHR")); + _vkGetPipelineExecutableInternalRepresentationsKHR = reinterpret_cast(loader("vkGetPipelineExecutableInternalRepresentationsKHR")); + _vkMapMemory2KHR = reinterpret_cast(loader("vkMapMemory2KHR")); + _vkUnmapMemory2KHR = reinterpret_cast(loader("vkUnmapMemory2KHR")); + _vkGetEncodedVideoSessionParametersKHR = reinterpret_cast(loader("vkGetEncodedVideoSessionParametersKHR")); + _vkCmdEncodeVideoKHR = reinterpret_cast(loader("vkCmdEncodeVideoKHR")); + _vkCmdSetEvent2KHR = reinterpret_cast(loader("vkCmdSetEvent2KHR")); + _vkCmdResetEvent2KHR = reinterpret_cast(loader("vkCmdResetEvent2KHR")); + _vkCmdWaitEvents2KHR = reinterpret_cast(loader("vkCmdWaitEvents2KHR")); + _vkCmdPipelineBarrier2KHR = reinterpret_cast(loader("vkCmdPipelineBarrier2KHR")); + _vkCmdWriteTimestamp2KHR = reinterpret_cast(loader("vkCmdWriteTimestamp2KHR")); + _vkQueueSubmit2KHR = reinterpret_cast(loader("vkQueueSubmit2KHR")); + _vkCmdWriteBufferMarker2AMD = reinterpret_cast(loader("vkCmdWriteBufferMarker2AMD")); + _vkGetQueueCheckpointData2NV = reinterpret_cast(loader("vkGetQueueCheckpointData2NV")); + _vkCmdCopyBuffer2KHR = reinterpret_cast(loader("vkCmdCopyBuffer2KHR")); + _vkCmdCopyImage2KHR = reinterpret_cast(loader("vkCmdCopyImage2KHR")); + _vkCmdCopyBufferToImage2KHR = reinterpret_cast(loader("vkCmdCopyBufferToImage2KHR")); + _vkCmdCopyImageToBuffer2KHR = reinterpret_cast(loader("vkCmdCopyImageToBuffer2KHR")); + _vkCmdBlitImage2KHR = reinterpret_cast(loader("vkCmdBlitImage2KHR")); + _vkCmdResolveImage2KHR = reinterpret_cast(loader("vkCmdResolveImage2KHR")); + _vkCmdTraceRaysIndirect2KHR = reinterpret_cast(loader("vkCmdTraceRaysIndirect2KHR")); + _vkGetDeviceBufferMemoryRequirementsKHR = reinterpret_cast(loader("vkGetDeviceBufferMemoryRequirementsKHR")); + _vkGetDeviceImageMemoryRequirementsKHR = reinterpret_cast(loader("vkGetDeviceImageMemoryRequirementsKHR")); + _vkGetDeviceImageSparseMemoryRequirementsKHR = reinterpret_cast(loader("vkGetDeviceImageSparseMemoryRequirementsKHR")); + _vkCmdBindIndexBuffer2KHR = reinterpret_cast(loader("vkCmdBindIndexBuffer2KHR")); + _vkGetRenderingAreaGranularityKHR = reinterpret_cast(loader("vkGetRenderingAreaGranularityKHR")); + _vkGetDeviceImageSubresourceLayoutKHR = reinterpret_cast(loader("vkGetDeviceImageSubresourceLayoutKHR")); + _vkGetImageSubresourceLayout2KHR = reinterpret_cast(loader("vkGetImageSubresourceLayout2KHR")); + _vkCmdSetLineStippleKHR = reinterpret_cast(loader("vkCmdSetLineStippleKHR")); + _vkGetCalibratedTimestampsKHR = reinterpret_cast(loader("vkGetCalibratedTimestampsKHR")); + _vkCmdBindDescriptorSets2KHR = reinterpret_cast(loader("vkCmdBindDescriptorSets2KHR")); + _vkCmdPushConstants2KHR = reinterpret_cast(loader("vkCmdPushConstants2KHR")); + _vkCmdPushDescriptorSet2KHR = reinterpret_cast(loader("vkCmdPushDescriptorSet2KHR")); + _vkCmdPushDescriptorSetWithTemplate2KHR = reinterpret_cast(loader("vkCmdPushDescriptorSetWithTemplate2KHR")); + _vkCmdSetDescriptorBufferOffsets2EXT = reinterpret_cast(loader("vkCmdSetDescriptorBufferOffsets2EXT")); + _vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = reinterpret_cast(loader("vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")); + _vkDebugMarkerSetObjectTagEXT = reinterpret_cast(loader("vkDebugMarkerSetObjectTagEXT")); + _vkDebugMarkerSetObjectNameEXT = reinterpret_cast(loader("vkDebugMarkerSetObjectNameEXT")); + _vkCmdDebugMarkerBeginEXT = reinterpret_cast(loader("vkCmdDebugMarkerBeginEXT")); + _vkCmdDebugMarkerEndEXT = reinterpret_cast(loader("vkCmdDebugMarkerEndEXT")); + _vkCmdDebugMarkerInsertEXT = reinterpret_cast(loader("vkCmdDebugMarkerInsertEXT")); + _vkCmdBindTransformFeedbackBuffersEXT = reinterpret_cast(loader("vkCmdBindTransformFeedbackBuffersEXT")); + _vkCmdBeginTransformFeedbackEXT = reinterpret_cast(loader("vkCmdBeginTransformFeedbackEXT")); + _vkCmdEndTransformFeedbackEXT = reinterpret_cast(loader("vkCmdEndTransformFeedbackEXT")); + _vkCmdBeginQueryIndexedEXT = reinterpret_cast(loader("vkCmdBeginQueryIndexedEXT")); + _vkCmdEndQueryIndexedEXT = reinterpret_cast(loader("vkCmdEndQueryIndexedEXT")); + _vkCmdDrawIndirectByteCountEXT = reinterpret_cast(loader("vkCmdDrawIndirectByteCountEXT")); + _vkCreateCuModuleNVX = reinterpret_cast(loader("vkCreateCuModuleNVX")); + _vkCreateCuFunctionNVX = reinterpret_cast(loader("vkCreateCuFunctionNVX")); + _vkDestroyCuModuleNVX = reinterpret_cast(loader("vkDestroyCuModuleNVX")); + _vkDestroyCuFunctionNVX = reinterpret_cast(loader("vkDestroyCuFunctionNVX")); + _vkCmdCuLaunchKernelNVX = reinterpret_cast(loader("vkCmdCuLaunchKernelNVX")); + _vkGetImageViewHandleNVX = reinterpret_cast(loader("vkGetImageViewHandleNVX")); + _vkGetImageViewAddressNVX = reinterpret_cast(loader("vkGetImageViewAddressNVX")); + _vkCmdDrawIndirectCountAMD = reinterpret_cast(loader("vkCmdDrawIndirectCountAMD")); + _vkCmdDrawIndexedIndirectCountAMD = reinterpret_cast(loader("vkCmdDrawIndexedIndirectCountAMD")); + _vkGetShaderInfoAMD = reinterpret_cast(loader("vkGetShaderInfoAMD")); + _vkCmdBeginConditionalRenderingEXT = reinterpret_cast(loader("vkCmdBeginConditionalRenderingEXT")); + _vkCmdEndConditionalRenderingEXT = reinterpret_cast(loader("vkCmdEndConditionalRenderingEXT")); + _vkCmdSetViewportWScalingNV = reinterpret_cast(loader("vkCmdSetViewportWScalingNV")); + _vkDisplayPowerControlEXT = reinterpret_cast(loader("vkDisplayPowerControlEXT")); + _vkRegisterDeviceEventEXT = reinterpret_cast(loader("vkRegisterDeviceEventEXT")); + _vkRegisterDisplayEventEXT = reinterpret_cast(loader("vkRegisterDisplayEventEXT")); + _vkGetSwapchainCounterEXT = reinterpret_cast(loader("vkGetSwapchainCounterEXT")); + _vkGetRefreshCycleDurationGOOGLE = reinterpret_cast(loader("vkGetRefreshCycleDurationGOOGLE")); + _vkGetPastPresentationTimingGOOGLE = reinterpret_cast(loader("vkGetPastPresentationTimingGOOGLE")); + _vkCmdSetDiscardRectangleEXT = reinterpret_cast(loader("vkCmdSetDiscardRectangleEXT")); + _vkCmdSetDiscardRectangleEnableEXT = reinterpret_cast(loader("vkCmdSetDiscardRectangleEnableEXT")); + _vkCmdSetDiscardRectangleModeEXT = reinterpret_cast(loader("vkCmdSetDiscardRectangleModeEXT")); + _vkSetHdrMetadataEXT = reinterpret_cast(loader("vkSetHdrMetadataEXT")); + _vkSetDebugUtilsObjectNameEXT = reinterpret_cast(loader("vkSetDebugUtilsObjectNameEXT")); + _vkSetDebugUtilsObjectTagEXT = reinterpret_cast(loader("vkSetDebugUtilsObjectTagEXT")); + _vkQueueBeginDebugUtilsLabelEXT = reinterpret_cast(loader("vkQueueBeginDebugUtilsLabelEXT")); + _vkQueueEndDebugUtilsLabelEXT = reinterpret_cast(loader("vkQueueEndDebugUtilsLabelEXT")); + _vkQueueInsertDebugUtilsLabelEXT = reinterpret_cast(loader("vkQueueInsertDebugUtilsLabelEXT")); + _vkCmdBeginDebugUtilsLabelEXT = reinterpret_cast(loader("vkCmdBeginDebugUtilsLabelEXT")); + _vkCmdEndDebugUtilsLabelEXT = reinterpret_cast(loader("vkCmdEndDebugUtilsLabelEXT")); + _vkCmdInsertDebugUtilsLabelEXT = reinterpret_cast(loader("vkCmdInsertDebugUtilsLabelEXT")); + _vkCmdSetSampleLocationsEXT = reinterpret_cast(loader("vkCmdSetSampleLocationsEXT")); + _vkGetImageDrmFormatModifierPropertiesEXT = reinterpret_cast(loader("vkGetImageDrmFormatModifierPropertiesEXT")); + _vkCreateValidationCacheEXT = reinterpret_cast(loader("vkCreateValidationCacheEXT")); + _vkDestroyValidationCacheEXT = reinterpret_cast(loader("vkDestroyValidationCacheEXT")); + _vkMergeValidationCachesEXT = reinterpret_cast(loader("vkMergeValidationCachesEXT")); + _vkGetValidationCacheDataEXT = reinterpret_cast(loader("vkGetValidationCacheDataEXT")); + _vkCmdBindShadingRateImageNV = reinterpret_cast(loader("vkCmdBindShadingRateImageNV")); + _vkCmdSetViewportShadingRatePaletteNV = reinterpret_cast(loader("vkCmdSetViewportShadingRatePaletteNV")); + _vkCmdSetCoarseSampleOrderNV = reinterpret_cast(loader("vkCmdSetCoarseSampleOrderNV")); + _vkCreateAccelerationStructureNV = reinterpret_cast(loader("vkCreateAccelerationStructureNV")); + _vkDestroyAccelerationStructureNV = reinterpret_cast(loader("vkDestroyAccelerationStructureNV")); + _vkGetAccelerationStructureMemoryRequirementsNV = reinterpret_cast(loader("vkGetAccelerationStructureMemoryRequirementsNV")); + _vkBindAccelerationStructureMemoryNV = reinterpret_cast(loader("vkBindAccelerationStructureMemoryNV")); + _vkCmdBuildAccelerationStructureNV = reinterpret_cast(loader("vkCmdBuildAccelerationStructureNV")); + _vkCmdCopyAccelerationStructureNV = reinterpret_cast(loader("vkCmdCopyAccelerationStructureNV")); + _vkCmdTraceRaysNV = reinterpret_cast(loader("vkCmdTraceRaysNV")); + _vkCreateRayTracingPipelinesNV = reinterpret_cast(loader("vkCreateRayTracingPipelinesNV")); + _vkGetRayTracingShaderGroupHandlesKHR = reinterpret_cast(loader("vkGetRayTracingShaderGroupHandlesKHR")); + _vkGetRayTracingShaderGroupHandlesNV = reinterpret_cast(loader("vkGetRayTracingShaderGroupHandlesNV")); + _vkGetAccelerationStructureHandleNV = reinterpret_cast(loader("vkGetAccelerationStructureHandleNV")); + _vkCmdWriteAccelerationStructuresPropertiesNV = reinterpret_cast(loader("vkCmdWriteAccelerationStructuresPropertiesNV")); + _vkCompileDeferredNV = reinterpret_cast(loader("vkCompileDeferredNV")); + _vkGetMemoryHostPointerPropertiesEXT = reinterpret_cast(loader("vkGetMemoryHostPointerPropertiesEXT")); + _vkCmdWriteBufferMarkerAMD = reinterpret_cast(loader("vkCmdWriteBufferMarkerAMD")); + _vkGetCalibratedTimestampsEXT = reinterpret_cast(loader("vkGetCalibratedTimestampsEXT")); + _vkCmdDrawMeshTasksNV = reinterpret_cast(loader("vkCmdDrawMeshTasksNV")); + _vkCmdDrawMeshTasksIndirectNV = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectNV")); + _vkCmdDrawMeshTasksIndirectCountNV = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectCountNV")); + _vkCmdSetExclusiveScissorEnableNV = reinterpret_cast(loader("vkCmdSetExclusiveScissorEnableNV")); + _vkCmdSetExclusiveScissorNV = reinterpret_cast(loader("vkCmdSetExclusiveScissorNV")); + _vkCmdSetCheckpointNV = reinterpret_cast(loader("vkCmdSetCheckpointNV")); + _vkGetQueueCheckpointDataNV = reinterpret_cast(loader("vkGetQueueCheckpointDataNV")); + _vkInitializePerformanceApiINTEL = reinterpret_cast(loader("vkInitializePerformanceApiINTEL")); + _vkUninitializePerformanceApiINTEL = reinterpret_cast(loader("vkUninitializePerformanceApiINTEL")); + _vkCmdSetPerformanceMarkerINTEL = reinterpret_cast(loader("vkCmdSetPerformanceMarkerINTEL")); + _vkCmdSetPerformanceStreamMarkerINTEL = reinterpret_cast(loader("vkCmdSetPerformanceStreamMarkerINTEL")); + _vkCmdSetPerformanceOverrideINTEL = reinterpret_cast(loader("vkCmdSetPerformanceOverrideINTEL")); + _vkAcquirePerformanceConfigurationINTEL = reinterpret_cast(loader("vkAcquirePerformanceConfigurationINTEL")); + _vkReleasePerformanceConfigurationINTEL = reinterpret_cast(loader("vkReleasePerformanceConfigurationINTEL")); + _vkQueueSetPerformanceConfigurationINTEL = reinterpret_cast(loader("vkQueueSetPerformanceConfigurationINTEL")); + _vkGetPerformanceParameterINTEL = reinterpret_cast(loader("vkGetPerformanceParameterINTEL")); + _vkSetLocalDimmingAMD = reinterpret_cast(loader("vkSetLocalDimmingAMD")); + _vkGetBufferDeviceAddressEXT = reinterpret_cast(loader("vkGetBufferDeviceAddressEXT")); + _vkCmdSetLineStippleEXT = reinterpret_cast(loader("vkCmdSetLineStippleEXT")); + _vkResetQueryPoolEXT = reinterpret_cast(loader("vkResetQueryPoolEXT")); + _vkCmdSetCullModeEXT = reinterpret_cast(loader("vkCmdSetCullModeEXT")); + _vkCmdSetFrontFaceEXT = reinterpret_cast(loader("vkCmdSetFrontFaceEXT")); + _vkCmdSetPrimitiveTopologyEXT = reinterpret_cast(loader("vkCmdSetPrimitiveTopologyEXT")); + _vkCmdSetViewportWithCountEXT = reinterpret_cast(loader("vkCmdSetViewportWithCountEXT")); + _vkCmdSetScissorWithCountEXT = reinterpret_cast(loader("vkCmdSetScissorWithCountEXT")); + _vkCmdBindVertexBuffers2EXT = reinterpret_cast(loader("vkCmdBindVertexBuffers2EXT")); + _vkCmdSetDepthTestEnableEXT = reinterpret_cast(loader("vkCmdSetDepthTestEnableEXT")); + _vkCmdSetDepthWriteEnableEXT = reinterpret_cast(loader("vkCmdSetDepthWriteEnableEXT")); + _vkCmdSetDepthCompareOpEXT = reinterpret_cast(loader("vkCmdSetDepthCompareOpEXT")); + _vkCmdSetDepthBoundsTestEnableEXT = reinterpret_cast(loader("vkCmdSetDepthBoundsTestEnableEXT")); + _vkCmdSetStencilTestEnableEXT = reinterpret_cast(loader("vkCmdSetStencilTestEnableEXT")); + _vkCmdSetStencilOpEXT = reinterpret_cast(loader("vkCmdSetStencilOpEXT")); + _vkCopyMemoryToImageEXT = reinterpret_cast(loader("vkCopyMemoryToImageEXT")); + _vkCopyImageToMemoryEXT = reinterpret_cast(loader("vkCopyImageToMemoryEXT")); + _vkCopyImageToImageEXT = reinterpret_cast(loader("vkCopyImageToImageEXT")); + _vkTransitionImageLayoutEXT = reinterpret_cast(loader("vkTransitionImageLayoutEXT")); + _vkGetImageSubresourceLayout2EXT = reinterpret_cast(loader("vkGetImageSubresourceLayout2EXT")); + _vkReleaseSwapchainImagesEXT = reinterpret_cast(loader("vkReleaseSwapchainImagesEXT")); + _vkGetGeneratedCommandsMemoryRequirementsNV = reinterpret_cast(loader("vkGetGeneratedCommandsMemoryRequirementsNV")); + _vkCmdPreprocessGeneratedCommandsNV = reinterpret_cast(loader("vkCmdPreprocessGeneratedCommandsNV")); + _vkCmdExecuteGeneratedCommandsNV = reinterpret_cast(loader("vkCmdExecuteGeneratedCommandsNV")); + _vkCmdBindPipelineShaderGroupNV = reinterpret_cast(loader("vkCmdBindPipelineShaderGroupNV")); + _vkCreateIndirectCommandsLayoutNV = reinterpret_cast(loader("vkCreateIndirectCommandsLayoutNV")); + _vkDestroyIndirectCommandsLayoutNV = reinterpret_cast(loader("vkDestroyIndirectCommandsLayoutNV")); + _vkCmdSetDepthBias2EXT = reinterpret_cast(loader("vkCmdSetDepthBias2EXT")); + _vkCreatePrivateDataSlotEXT = reinterpret_cast(loader("vkCreatePrivateDataSlotEXT")); + _vkDestroyPrivateDataSlotEXT = reinterpret_cast(loader("vkDestroyPrivateDataSlotEXT")); + _vkSetPrivateDataEXT = reinterpret_cast(loader("vkSetPrivateDataEXT")); + _vkGetPrivateDataEXT = reinterpret_cast(loader("vkGetPrivateDataEXT")); + _vkCreateCudaModuleNV = reinterpret_cast(loader("vkCreateCudaModuleNV")); + _vkGetCudaModuleCacheNV = reinterpret_cast(loader("vkGetCudaModuleCacheNV")); + _vkCreateCudaFunctionNV = reinterpret_cast(loader("vkCreateCudaFunctionNV")); + _vkDestroyCudaModuleNV = reinterpret_cast(loader("vkDestroyCudaModuleNV")); + _vkDestroyCudaFunctionNV = reinterpret_cast(loader("vkDestroyCudaFunctionNV")); + _vkCmdCudaLaunchKernelNV = reinterpret_cast(loader("vkCmdCudaLaunchKernelNV")); + _vkGetDescriptorSetLayoutSizeEXT = reinterpret_cast(loader("vkGetDescriptorSetLayoutSizeEXT")); + _vkGetDescriptorSetLayoutBindingOffsetEXT = reinterpret_cast(loader("vkGetDescriptorSetLayoutBindingOffsetEXT")); + _vkGetDescriptorEXT = reinterpret_cast(loader("vkGetDescriptorEXT")); + _vkCmdBindDescriptorBuffersEXT = reinterpret_cast(loader("vkCmdBindDescriptorBuffersEXT")); + _vkCmdSetDescriptorBufferOffsetsEXT = reinterpret_cast(loader("vkCmdSetDescriptorBufferOffsetsEXT")); + _vkCmdBindDescriptorBufferEmbeddedSamplersEXT = reinterpret_cast(loader("vkCmdBindDescriptorBufferEmbeddedSamplersEXT")); + _vkGetBufferOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetBufferOpaqueCaptureDescriptorDataEXT")); + _vkGetImageOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetImageOpaqueCaptureDescriptorDataEXT")); + _vkGetImageViewOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetImageViewOpaqueCaptureDescriptorDataEXT")); + _vkGetSamplerOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetSamplerOpaqueCaptureDescriptorDataEXT")); + _vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")); + _vkCmdSetFragmentShadingRateEnumNV = reinterpret_cast(loader("vkCmdSetFragmentShadingRateEnumNV")); + _vkGetDeviceFaultInfoEXT = reinterpret_cast(loader("vkGetDeviceFaultInfoEXT")); + _vkCmdSetVertexInputEXT = reinterpret_cast(loader("vkCmdSetVertexInputEXT")); + _vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = reinterpret_cast(loader("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")); + _vkCmdSubpassShadingHUAWEI = reinterpret_cast(loader("vkCmdSubpassShadingHUAWEI")); + _vkCmdBindInvocationMaskHUAWEI = reinterpret_cast(loader("vkCmdBindInvocationMaskHUAWEI")); + _vkGetMemoryRemoteAddressNV = reinterpret_cast(loader("vkGetMemoryRemoteAddressNV")); + _vkGetPipelinePropertiesEXT = reinterpret_cast(loader("vkGetPipelinePropertiesEXT")); + _vkCmdSetPatchControlPointsEXT = reinterpret_cast(loader("vkCmdSetPatchControlPointsEXT")); + _vkCmdSetRasterizerDiscardEnableEXT = reinterpret_cast(loader("vkCmdSetRasterizerDiscardEnableEXT")); + _vkCmdSetDepthBiasEnableEXT = reinterpret_cast(loader("vkCmdSetDepthBiasEnableEXT")); + _vkCmdSetLogicOpEXT = reinterpret_cast(loader("vkCmdSetLogicOpEXT")); + _vkCmdSetPrimitiveRestartEnableEXT = reinterpret_cast(loader("vkCmdSetPrimitiveRestartEnableEXT")); + _vkCmdSetColorWriteEnableEXT = reinterpret_cast(loader("vkCmdSetColorWriteEnableEXT")); + _vkCmdDrawMultiEXT = reinterpret_cast(loader("vkCmdDrawMultiEXT")); + _vkCmdDrawMultiIndexedEXT = reinterpret_cast(loader("vkCmdDrawMultiIndexedEXT")); + _vkCreateMicromapEXT = reinterpret_cast(loader("vkCreateMicromapEXT")); + _vkDestroyMicromapEXT = reinterpret_cast(loader("vkDestroyMicromapEXT")); + _vkCmdBuildMicromapsEXT = reinterpret_cast(loader("vkCmdBuildMicromapsEXT")); + _vkBuildMicromapsEXT = reinterpret_cast(loader("vkBuildMicromapsEXT")); + _vkCopyMicromapEXT = reinterpret_cast(loader("vkCopyMicromapEXT")); + _vkCopyMicromapToMemoryEXT = reinterpret_cast(loader("vkCopyMicromapToMemoryEXT")); + _vkCopyMemoryToMicromapEXT = reinterpret_cast(loader("vkCopyMemoryToMicromapEXT")); + _vkWriteMicromapsPropertiesEXT = reinterpret_cast(loader("vkWriteMicromapsPropertiesEXT")); + _vkCmdCopyMicromapEXT = reinterpret_cast(loader("vkCmdCopyMicromapEXT")); + _vkCmdCopyMicromapToMemoryEXT = reinterpret_cast(loader("vkCmdCopyMicromapToMemoryEXT")); + _vkCmdCopyMemoryToMicromapEXT = reinterpret_cast(loader("vkCmdCopyMemoryToMicromapEXT")); + _vkCmdWriteMicromapsPropertiesEXT = reinterpret_cast(loader("vkCmdWriteMicromapsPropertiesEXT")); + _vkGetDeviceMicromapCompatibilityEXT = reinterpret_cast(loader("vkGetDeviceMicromapCompatibilityEXT")); + _vkGetMicromapBuildSizesEXT = reinterpret_cast(loader("vkGetMicromapBuildSizesEXT")); + _vkCmdDrawClusterHUAWEI = reinterpret_cast(loader("vkCmdDrawClusterHUAWEI")); + _vkCmdDrawClusterIndirectHUAWEI = reinterpret_cast(loader("vkCmdDrawClusterIndirectHUAWEI")); + _vkSetDeviceMemoryPriorityEXT = reinterpret_cast(loader("vkSetDeviceMemoryPriorityEXT")); + _vkGetDescriptorSetLayoutHostMappingInfoVALVE = reinterpret_cast(loader("vkGetDescriptorSetLayoutHostMappingInfoVALVE")); + _vkGetDescriptorSetHostMappingVALVE = reinterpret_cast(loader("vkGetDescriptorSetHostMappingVALVE")); + _vkCmdCopyMemoryIndirectNV = reinterpret_cast(loader("vkCmdCopyMemoryIndirectNV")); + _vkCmdCopyMemoryToImageIndirectNV = reinterpret_cast(loader("vkCmdCopyMemoryToImageIndirectNV")); + _vkCmdDecompressMemoryNV = reinterpret_cast(loader("vkCmdDecompressMemoryNV")); + _vkCmdDecompressMemoryIndirectCountNV = reinterpret_cast(loader("vkCmdDecompressMemoryIndirectCountNV")); + _vkGetPipelineIndirectMemoryRequirementsNV = reinterpret_cast(loader("vkGetPipelineIndirectMemoryRequirementsNV")); + _vkCmdUpdatePipelineIndirectBufferNV = reinterpret_cast(loader("vkCmdUpdatePipelineIndirectBufferNV")); + _vkGetPipelineIndirectDeviceAddressNV = reinterpret_cast(loader("vkGetPipelineIndirectDeviceAddressNV")); + _vkCmdSetDepthClampEnableEXT = reinterpret_cast(loader("vkCmdSetDepthClampEnableEXT")); + _vkCmdSetPolygonModeEXT = reinterpret_cast(loader("vkCmdSetPolygonModeEXT")); + _vkCmdSetRasterizationSamplesEXT = reinterpret_cast(loader("vkCmdSetRasterizationSamplesEXT")); + _vkCmdSetSampleMaskEXT = reinterpret_cast(loader("vkCmdSetSampleMaskEXT")); + _vkCmdSetAlphaToCoverageEnableEXT = reinterpret_cast(loader("vkCmdSetAlphaToCoverageEnableEXT")); + _vkCmdSetAlphaToOneEnableEXT = reinterpret_cast(loader("vkCmdSetAlphaToOneEnableEXT")); + _vkCmdSetLogicOpEnableEXT = reinterpret_cast(loader("vkCmdSetLogicOpEnableEXT")); + _vkCmdSetColorBlendEnableEXT = reinterpret_cast(loader("vkCmdSetColorBlendEnableEXT")); + _vkCmdSetColorBlendEquationEXT = reinterpret_cast(loader("vkCmdSetColorBlendEquationEXT")); + _vkCmdSetColorWriteMaskEXT = reinterpret_cast(loader("vkCmdSetColorWriteMaskEXT")); + _vkCmdSetTessellationDomainOriginEXT = reinterpret_cast(loader("vkCmdSetTessellationDomainOriginEXT")); + _vkCmdSetRasterizationStreamEXT = reinterpret_cast(loader("vkCmdSetRasterizationStreamEXT")); + _vkCmdSetConservativeRasterizationModeEXT = reinterpret_cast(loader("vkCmdSetConservativeRasterizationModeEXT")); + _vkCmdSetExtraPrimitiveOverestimationSizeEXT = reinterpret_cast(loader("vkCmdSetExtraPrimitiveOverestimationSizeEXT")); + _vkCmdSetDepthClipEnableEXT = reinterpret_cast(loader("vkCmdSetDepthClipEnableEXT")); + _vkCmdSetSampleLocationsEnableEXT = reinterpret_cast(loader("vkCmdSetSampleLocationsEnableEXT")); + _vkCmdSetColorBlendAdvancedEXT = reinterpret_cast(loader("vkCmdSetColorBlendAdvancedEXT")); + _vkCmdSetProvokingVertexModeEXT = reinterpret_cast(loader("vkCmdSetProvokingVertexModeEXT")); + _vkCmdSetLineRasterizationModeEXT = reinterpret_cast(loader("vkCmdSetLineRasterizationModeEXT")); + _vkCmdSetLineStippleEnableEXT = reinterpret_cast(loader("vkCmdSetLineStippleEnableEXT")); + _vkCmdSetDepthClipNegativeOneToOneEXT = reinterpret_cast(loader("vkCmdSetDepthClipNegativeOneToOneEXT")); + _vkCmdSetViewportWScalingEnableNV = reinterpret_cast(loader("vkCmdSetViewportWScalingEnableNV")); + _vkCmdSetViewportSwizzleNV = reinterpret_cast(loader("vkCmdSetViewportSwizzleNV")); + _vkCmdSetCoverageToColorEnableNV = reinterpret_cast(loader("vkCmdSetCoverageToColorEnableNV")); + _vkCmdSetCoverageToColorLocationNV = reinterpret_cast(loader("vkCmdSetCoverageToColorLocationNV")); + _vkCmdSetCoverageModulationModeNV = reinterpret_cast(loader("vkCmdSetCoverageModulationModeNV")); + _vkCmdSetCoverageModulationTableEnableNV = reinterpret_cast(loader("vkCmdSetCoverageModulationTableEnableNV")); + _vkCmdSetCoverageModulationTableNV = reinterpret_cast(loader("vkCmdSetCoverageModulationTableNV")); + _vkCmdSetShadingRateImageEnableNV = reinterpret_cast(loader("vkCmdSetShadingRateImageEnableNV")); + _vkCmdSetRepresentativeFragmentTestEnableNV = reinterpret_cast(loader("vkCmdSetRepresentativeFragmentTestEnableNV")); + _vkCmdSetCoverageReductionModeNV = reinterpret_cast(loader("vkCmdSetCoverageReductionModeNV")); + _vkGetShaderModuleIdentifierEXT = reinterpret_cast(loader("vkGetShaderModuleIdentifierEXT")); + _vkGetShaderModuleCreateInfoIdentifierEXT = reinterpret_cast(loader("vkGetShaderModuleCreateInfoIdentifierEXT")); + _vkCreateOpticalFlowSessionNV = reinterpret_cast(loader("vkCreateOpticalFlowSessionNV")); + _vkDestroyOpticalFlowSessionNV = reinterpret_cast(loader("vkDestroyOpticalFlowSessionNV")); + _vkBindOpticalFlowSessionImageNV = reinterpret_cast(loader("vkBindOpticalFlowSessionImageNV")); + _vkCmdOpticalFlowExecuteNV = reinterpret_cast(loader("vkCmdOpticalFlowExecuteNV")); + _vkCreateShadersEXT = reinterpret_cast(loader("vkCreateShadersEXT")); + _vkDestroyShaderEXT = reinterpret_cast(loader("vkDestroyShaderEXT")); + _vkGetShaderBinaryDataEXT = reinterpret_cast(loader("vkGetShaderBinaryDataEXT")); + _vkCmdBindShadersEXT = reinterpret_cast(loader("vkCmdBindShadersEXT")); + _vkGetFramebufferTilePropertiesQCOM = reinterpret_cast(loader("vkGetFramebufferTilePropertiesQCOM")); + _vkGetDynamicRenderingTilePropertiesQCOM = reinterpret_cast(loader("vkGetDynamicRenderingTilePropertiesQCOM")); + _vkSetLatencySleepModeNV = reinterpret_cast(loader("vkSetLatencySleepModeNV")); + _vkLatencySleepNV = reinterpret_cast(loader("vkLatencySleepNV")); + _vkSetLatencyMarkerNV = reinterpret_cast(loader("vkSetLatencyMarkerNV")); + _vkGetLatencyTimingsNV = reinterpret_cast(loader("vkGetLatencyTimingsNV")); + _vkQueueNotifyOutOfBandNV = reinterpret_cast(loader("vkQueueNotifyOutOfBandNV")); + _vkCmdSetAttachmentFeedbackLoopEnableEXT = reinterpret_cast(loader("vkCmdSetAttachmentFeedbackLoopEnableEXT")); + _vkCreateAccelerationStructureKHR = reinterpret_cast(loader("vkCreateAccelerationStructureKHR")); + _vkDestroyAccelerationStructureKHR = reinterpret_cast(loader("vkDestroyAccelerationStructureKHR")); + _vkCmdBuildAccelerationStructuresKHR = reinterpret_cast(loader("vkCmdBuildAccelerationStructuresKHR")); + _vkCmdBuildAccelerationStructuresIndirectKHR = reinterpret_cast(loader("vkCmdBuildAccelerationStructuresIndirectKHR")); + _vkBuildAccelerationStructuresKHR = reinterpret_cast(loader("vkBuildAccelerationStructuresKHR")); + _vkCopyAccelerationStructureKHR = reinterpret_cast(loader("vkCopyAccelerationStructureKHR")); + _vkCopyAccelerationStructureToMemoryKHR = reinterpret_cast(loader("vkCopyAccelerationStructureToMemoryKHR")); + _vkCopyMemoryToAccelerationStructureKHR = reinterpret_cast(loader("vkCopyMemoryToAccelerationStructureKHR")); + _vkWriteAccelerationStructuresPropertiesKHR = reinterpret_cast(loader("vkWriteAccelerationStructuresPropertiesKHR")); + _vkCmdCopyAccelerationStructureKHR = reinterpret_cast(loader("vkCmdCopyAccelerationStructureKHR")); + _vkCmdCopyAccelerationStructureToMemoryKHR = reinterpret_cast(loader("vkCmdCopyAccelerationStructureToMemoryKHR")); + _vkCmdCopyMemoryToAccelerationStructureKHR = reinterpret_cast(loader("vkCmdCopyMemoryToAccelerationStructureKHR")); + _vkGetAccelerationStructureDeviceAddressKHR = reinterpret_cast(loader("vkGetAccelerationStructureDeviceAddressKHR")); + _vkCmdWriteAccelerationStructuresPropertiesKHR = reinterpret_cast(loader("vkCmdWriteAccelerationStructuresPropertiesKHR")); + _vkGetDeviceAccelerationStructureCompatibilityKHR = reinterpret_cast(loader("vkGetDeviceAccelerationStructureCompatibilityKHR")); + _vkGetAccelerationStructureBuildSizesKHR = reinterpret_cast(loader("vkGetAccelerationStructureBuildSizesKHR")); + _vkCmdTraceRaysKHR = reinterpret_cast(loader("vkCmdTraceRaysKHR")); + _vkCreateRayTracingPipelinesKHR = reinterpret_cast(loader("vkCreateRayTracingPipelinesKHR")); + _vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = reinterpret_cast(loader("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")); + _vkCmdTraceRaysIndirectKHR = reinterpret_cast(loader("vkCmdTraceRaysIndirectKHR")); + _vkGetRayTracingShaderGroupStackSizeKHR = reinterpret_cast(loader("vkGetRayTracingShaderGroupStackSizeKHR")); + _vkCmdSetRayTracingPipelineStackSizeKHR = reinterpret_cast(loader("vkCmdSetRayTracingPipelineStackSizeKHR")); + _vkCmdDrawMeshTasksEXT = reinterpret_cast(loader("vkCmdDrawMeshTasksEXT")); + _vkCmdDrawMeshTasksIndirectEXT = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectEXT")); + _vkCmdDrawMeshTasksIndirectCountEXT = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectCountEXT")); + + } + VulkanDeviceFunctions(){} + void vkDestroyDevice(const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDevice(_device, pAllocator); + } + void vkGetDeviceQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) const { + _vkGetDeviceQueue(_device, queueFamilyIndex, queueIndex, pQueue); + } + VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) const { + return _vkQueueSubmit(queue, submitCount, pSubmits, fence); + } + VkResult vkQueueWaitIdle(VkQueue queue) const { + return _vkQueueWaitIdle(queue); + } + VkResult vkDeviceWaitIdle() const { + return _vkDeviceWaitIdle(_device); + } + VkResult vkAllocateMemory(const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) const { + return _vkAllocateMemory(_device, pAllocateInfo, pAllocator, pMemory); + } + void vkFreeMemory(VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) const { + _vkFreeMemory(_device, memory, pAllocator); + } + VkResult vkMapMemory(VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const { + return _vkMapMemory(_device, memory, offset, size, flags, ppData); + } + void vkUnmapMemory(VkDeviceMemory memory) const { + _vkUnmapMemory(_device, memory); + } + VkResult vkFlushMappedMemoryRanges(uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const { + return _vkFlushMappedMemoryRanges(_device, memoryRangeCount, pMemoryRanges); + } + VkResult vkInvalidateMappedMemoryRanges(uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const { + return _vkInvalidateMappedMemoryRanges(_device, memoryRangeCount, pMemoryRanges); + } + void vkGetDeviceMemoryCommitment(VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const { + _vkGetDeviceMemoryCommitment(_device, memory, pCommittedMemoryInBytes); + } + VkResult vkBindBufferMemory(VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const { + return _vkBindBufferMemory(_device, buffer, memory, memoryOffset); + } + VkResult vkBindImageMemory(VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const { + return _vkBindImageMemory(_device, image, memory, memoryOffset); + } + void vkGetBufferMemoryRequirements(VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const { + _vkGetBufferMemoryRequirements(_device, buffer, pMemoryRequirements); + } + void vkGetImageMemoryRequirements(VkImage image, VkMemoryRequirements* pMemoryRequirements) const { + _vkGetImageMemoryRequirements(_device, image, pMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements(VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const { + _vkGetImageSparseMemoryRequirements(_device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) const { + return _vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + } + VkResult vkCreateFence(const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const { + return _vkCreateFence(_device, pCreateInfo, pAllocator, pFence); + } + void vkDestroyFence(VkFence fence, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyFence(_device, fence, pAllocator); + } + VkResult vkResetFences(uint32_t fenceCount, const VkFence* pFences) const { + return _vkResetFences(_device, fenceCount, pFences); + } + VkResult vkGetFenceStatus(VkFence fence) const { + return _vkGetFenceStatus(_device, fence); + } + VkResult vkWaitForFences(uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) const { + return _vkWaitForFences(_device, fenceCount, pFences, waitAll, timeout); + } + VkResult vkCreateSemaphore(const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) const { + return _vkCreateSemaphore(_device, pCreateInfo, pAllocator, pSemaphore); + } + void vkDestroySemaphore(VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySemaphore(_device, semaphore, pAllocator); + } + VkResult vkCreateEvent(const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) const { + return _vkCreateEvent(_device, pCreateInfo, pAllocator, pEvent); + } + void vkDestroyEvent(VkEvent event, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyEvent(_device, event, pAllocator); + } + VkResult vkGetEventStatus(VkEvent event) const { + return _vkGetEventStatus(_device, event); + } + VkResult vkSetEvent(VkEvent event) const { + return _vkSetEvent(_device, event); + } + VkResult vkResetEvent(VkEvent event) const { + return _vkResetEvent(_device, event); + } + VkResult vkCreateQueryPool(const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const { + return _vkCreateQueryPool(_device, pCreateInfo, pAllocator, pQueryPool); + } + void vkDestroyQueryPool(VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyQueryPool(_device, queryPool, pAllocator); + } + VkResult vkGetQueryPoolResults(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const { + return _vkGetQueryPoolResults(_device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + } + VkResult vkCreateBuffer(const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const { + return _vkCreateBuffer(_device, pCreateInfo, pAllocator, pBuffer); + } + void vkDestroyBuffer(VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyBuffer(_device, buffer, pAllocator); + } + VkResult vkCreateBufferView(const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const { + return _vkCreateBufferView(_device, pCreateInfo, pAllocator, pView); + } + void vkDestroyBufferView(VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyBufferView(_device, bufferView, pAllocator); + } + VkResult vkCreateImage(const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) const { + return _vkCreateImage(_device, pCreateInfo, pAllocator, pImage); + } + void vkDestroyImage(VkImage image, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyImage(_device, image, pAllocator); + } + void vkGetImageSubresourceLayout(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const { + _vkGetImageSubresourceLayout(_device, image, pSubresource, pLayout); + } + VkResult vkCreateImageView(const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) const { + return _vkCreateImageView(_device, pCreateInfo, pAllocator, pView); + } + void vkDestroyImageView(VkImageView imageView, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyImageView(_device, imageView, pAllocator); + } + VkResult vkCreateShaderModule(const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) const { + return _vkCreateShaderModule(_device, pCreateInfo, pAllocator, pShaderModule); + } + void vkDestroyShaderModule(VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyShaderModule(_device, shaderModule, pAllocator); + } + VkResult vkCreatePipelineCache(const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) const { + return _vkCreatePipelineCache(_device, pCreateInfo, pAllocator, pPipelineCache); + } + void vkDestroyPipelineCache(VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPipelineCache(_device, pipelineCache, pAllocator); + } + VkResult vkGetPipelineCacheData(VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) const { + return _vkGetPipelineCacheData(_device, pipelineCache, pDataSize, pData); + } + VkResult vkMergePipelineCaches(VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) const { + return _vkMergePipelineCaches(_device, dstCache, srcCacheCount, pSrcCaches); + } + VkResult vkCreateGraphicsPipelines(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateGraphicsPipelines(_device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult vkCreateComputePipelines(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateComputePipelines(_device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + void vkDestroyPipeline(VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPipeline(_device, pipeline, pAllocator); + } + VkResult vkCreatePipelineLayout(const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) const { + return _vkCreatePipelineLayout(_device, pCreateInfo, pAllocator, pPipelineLayout); + } + void vkDestroyPipelineLayout(VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPipelineLayout(_device, pipelineLayout, pAllocator); + } + VkResult vkCreateSampler(const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) const { + return _vkCreateSampler(_device, pCreateInfo, pAllocator, pSampler); + } + void vkDestroySampler(VkSampler sampler, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySampler(_device, sampler, pAllocator); + } + VkResult vkCreateDescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) const { + return _vkCreateDescriptorSetLayout(_device, pCreateInfo, pAllocator, pSetLayout); + } + void vkDestroyDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorSetLayout(_device, descriptorSetLayout, pAllocator); + } + VkResult vkCreateDescriptorPool(const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) const { + return _vkCreateDescriptorPool(_device, pCreateInfo, pAllocator, pDescriptorPool); + } + void vkDestroyDescriptorPool(VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorPool(_device, descriptorPool, pAllocator); + } + VkResult vkResetDescriptorPool(VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const { + return _vkResetDescriptorPool(_device, descriptorPool, flags); + } + VkResult vkAllocateDescriptorSets(const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) const { + return _vkAllocateDescriptorSets(_device, pAllocateInfo, pDescriptorSets); + } + VkResult vkFreeDescriptorSets(VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) const { + return _vkFreeDescriptorSets(_device, descriptorPool, descriptorSetCount, pDescriptorSets); + } + void vkUpdateDescriptorSets(uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) const { + _vkUpdateDescriptorSets(_device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + } + VkResult vkCreateFramebuffer(const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) const { + return _vkCreateFramebuffer(_device, pCreateInfo, pAllocator, pFramebuffer); + } + void vkDestroyFramebuffer(VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyFramebuffer(_device, framebuffer, pAllocator); + } + VkResult vkCreateRenderPass(const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const { + return _vkCreateRenderPass(_device, pCreateInfo, pAllocator, pRenderPass); + } + void vkDestroyRenderPass(VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyRenderPass(_device, renderPass, pAllocator); + } + void vkGetRenderAreaGranularity(VkRenderPass renderPass, VkExtent2D* pGranularity) const { + _vkGetRenderAreaGranularity(_device, renderPass, pGranularity); + } + VkResult vkCreateCommandPool(const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) const { + return _vkCreateCommandPool(_device, pCreateInfo, pAllocator, pCommandPool); + } + void vkDestroyCommandPool(VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCommandPool(_device, commandPool, pAllocator); + } + VkResult vkResetCommandPool(VkCommandPool commandPool, VkCommandPoolResetFlags flags) const { + return _vkResetCommandPool(_device, commandPool, flags); + } + VkResult vkAllocateCommandBuffers(const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) const { + return _vkAllocateCommandBuffers(_device, pAllocateInfo, pCommandBuffers); + } + void vkFreeCommandBuffers(VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const { + _vkFreeCommandBuffers(_device, commandPool, commandBufferCount, pCommandBuffers); + } + VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) const { + return _vkBeginCommandBuffer(commandBuffer, pBeginInfo); + } + VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) const { + return _vkEndCommandBuffer(commandBuffer); + } + VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const { + return _vkResetCommandBuffer(commandBuffer, flags); + } + void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const { + _vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); + } + void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) const { + _vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); + } + void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) const { + _vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); + } + void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const { + _vkCmdSetLineWidth(commandBuffer, lineWidth); + } + void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const { + _vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + } + void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const { + _vkCmdSetBlendConstants(commandBuffer, blendConstants); + } + void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const { + _vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); + } + void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const { + _vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); + } + void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const { + _vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); + } + void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const { + _vkCmdSetStencilReference(commandBuffer, faceMask, reference); + } + void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) const { + _vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + } + void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const { + _vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); + } + void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const { + _vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + } + void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const { + _vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + } + void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const { + _vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + } + void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const { + _vkCmdDispatchIndirect(commandBuffer, buffer, offset); + } + void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) const { + _vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + } + void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) const { + _vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) const { + _vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + } + void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) const { + _vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) const { + _vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + } + void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) const { + _vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); + } + void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const { + _vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); + } + void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const { + _vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + } + void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const { + _vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + } + void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) const { + _vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + } + void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) const { + _vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const { + _vkCmdSetEvent(commandBuffer, event, stageMask); + } + void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const { + _vkCmdResetEvent(commandBuffer, event, stageMask); + } + void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const { + _vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + } + void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const { + _vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + } + void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const { + _vkCmdBeginQuery(commandBuffer, queryPool, query, flags); + } + void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const { + _vkCmdEndQuery(commandBuffer, queryPool, query); + } + void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const { + _vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); + } + void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) const { + _vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); + } + void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const { + _vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + } + void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) const { + _vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); + } + void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const { + _vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); + } + void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const { + _vkCmdNextSubpass(commandBuffer, contents); + } + void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const { + _vkCmdEndRenderPass(commandBuffer); + } + void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const { + _vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); + } + VkResult vkBindBufferMemory2(uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const { + return _vkBindBufferMemory2(_device, bindInfoCount, pBindInfos); + } + VkResult vkBindImageMemory2(uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const { + return _vkBindImageMemory2(_device, bindInfoCount, pBindInfos); + } + void vkGetDeviceGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const { + _vkGetDeviceGroupPeerMemoryFeatures(_device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + } + void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const { + _vkCmdSetDeviceMask(commandBuffer, deviceMask); + } + void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } + void vkGetImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetImageMemoryRequirements2(_device, pInfo, pMemoryRequirements); + } + void vkGetBufferMemoryRequirements2(const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetBufferMemoryRequirements2(_device, pInfo, pMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements2(const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetImageSparseMemoryRequirements2(_device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkTrimCommandPool(VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const { + _vkTrimCommandPool(_device, commandPool, flags); + } + void vkGetDeviceQueue2(const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const { + _vkGetDeviceQueue2(_device, pQueueInfo, pQueue); + } + VkResult vkCreateSamplerYcbcrConversion(const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const { + return _vkCreateSamplerYcbcrConversion(_device, pCreateInfo, pAllocator, pYcbcrConversion); + } + void vkDestroySamplerYcbcrConversion(VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySamplerYcbcrConversion(_device, ycbcrConversion, pAllocator); + } + VkResult vkCreateDescriptorUpdateTemplate(const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const { + return _vkCreateDescriptorUpdateTemplate(_device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + } + void vkDestroyDescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorUpdateTemplate(_device, descriptorUpdateTemplate, pAllocator); + } + void vkUpdateDescriptorSetWithTemplate(VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const { + _vkUpdateDescriptorSetWithTemplate(_device, descriptorSet, descriptorUpdateTemplate, pData); + } + void vkGetDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const { + _vkGetDescriptorSetLayoutSupport(_device, pCreateInfo, pSupport); + } + void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + VkResult vkCreateRenderPass2(const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const { + return _vkCreateRenderPass2(_device, pCreateInfo, pAllocator, pRenderPass); + } + void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) const { + _vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + } + void vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + } + void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo); + } + void vkResetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const { + _vkResetQueryPool(_device, queryPool, firstQuery, queryCount); + } + VkResult vkGetSemaphoreCounterValue(VkSemaphore semaphore, uint64_t* pValue) const { + return _vkGetSemaphoreCounterValue(_device, semaphore, pValue); + } + VkResult vkWaitSemaphores(const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) const { + return _vkWaitSemaphores(_device, pWaitInfo, timeout); + } + VkResult vkSignalSemaphore(const VkSemaphoreSignalInfo* pSignalInfo) const { + return _vkSignalSemaphore(_device, pSignalInfo); + } + VkDeviceAddress vkGetBufferDeviceAddress(const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferDeviceAddress(_device, pInfo); + } + uint64_t vkGetBufferOpaqueCaptureAddress(const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferOpaqueCaptureAddress(_device, pInfo); + } + uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const { + return _vkGetDeviceMemoryOpaqueCaptureAddress(_device, pInfo); + } + VkResult vkCreatePrivateDataSlot(const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) const { + return _vkCreatePrivateDataSlot(_device, pCreateInfo, pAllocator, pPrivateDataSlot); + } + void vkDestroyPrivateDataSlot(VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPrivateDataSlot(_device, privateDataSlot, pAllocator); + } + VkResult vkSetPrivateData(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const { + return _vkSetPrivateData(_device, objectType, objectHandle, privateDataSlot, data); + } + void vkGetPrivateData(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) const { + _vkGetPrivateData(_device, objectType, objectHandle, privateDataSlot, pData); + } + void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdSetEvent2(commandBuffer, event, pDependencyInfo); + } + void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const { + _vkCmdResetEvent2(commandBuffer, event, stageMask); + } + void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) const { + _vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); + } + void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo); + } + void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const { + _vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query); + } + VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) const { + return _vkQueueSubmit2(queue, submitCount, pSubmits, fence); + } + void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) const { + _vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo); + } + void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) const { + _vkCmdCopyImage2(commandBuffer, pCopyImageInfo); + } + void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) const { + _vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); + } + void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) const { + _vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); + } + void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) const { + _vkCmdBlitImage2(commandBuffer, pBlitImageInfo); + } + void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) const { + _vkCmdResolveImage2(commandBuffer, pResolveImageInfo); + } + void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) const { + _vkCmdBeginRendering(commandBuffer, pRenderingInfo); + } + void vkCmdEndRendering(VkCommandBuffer commandBuffer) const { + _vkCmdEndRendering(commandBuffer); + } + void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const { + _vkCmdSetCullMode(commandBuffer, cullMode); + } + void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const { + _vkCmdSetFrontFace(commandBuffer, frontFace); + } + void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const { + _vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology); + } + void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const { + _vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); + } + void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const { + _vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); + } + void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const { + _vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + } + void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const { + _vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable); + } + void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const { + _vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); + } + void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const { + _vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp); + } + void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const { + _vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); + } + void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const { + _vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable); + } + void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const { + _vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + } + void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const { + _vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); + } + void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const { + _vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); + } + void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const { + _vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); + } + void vkGetDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceBufferMemoryRequirements(_device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceImageMemoryRequirements(_device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageSparseMemoryRequirements(const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetDeviceImageSparseMemoryRequirements(_device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + VkResult vkCreateSwapchainKHR(const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) const { + return _vkCreateSwapchainKHR(_device, pCreateInfo, pAllocator, pSwapchain); + } + void vkDestroySwapchainKHR(VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySwapchainKHR(_device, swapchain, pAllocator); + } + VkResult vkGetSwapchainImagesKHR(VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) const { + return _vkGetSwapchainImagesKHR(_device, swapchain, pSwapchainImageCount, pSwapchainImages); + } + VkResult vkAcquireNextImageKHR(VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) const { + return _vkAcquireNextImageKHR(_device, swapchain, timeout, semaphore, fence, pImageIndex); + } + VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const { + return _vkQueuePresentKHR(queue, pPresentInfo); + } + VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const { + return _vkGetDeviceGroupPresentCapabilitiesKHR(_device, pDeviceGroupPresentCapabilities); + } + VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) const { + return _vkGetDeviceGroupSurfacePresentModesKHR(_device, surface, pModes); + } + VkResult vkAcquireNextImage2KHR(const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) const { + return _vkAcquireNextImage2KHR(_device, pAcquireInfo, pImageIndex); + } + VkResult vkCreateSharedSwapchainsKHR(uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const { + return _vkCreateSharedSwapchainsKHR(_device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + } + VkResult vkCreateVideoSessionKHR(const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) const { + return _vkCreateVideoSessionKHR(_device, pCreateInfo, pAllocator, pVideoSession); + } + void vkDestroyVideoSessionKHR(VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyVideoSessionKHR(_device, videoSession, pAllocator); + } + VkResult vkGetVideoSessionMemoryRequirementsKHR(VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) const { + return _vkGetVideoSessionMemoryRequirementsKHR(_device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); + } + VkResult vkBindVideoSessionMemoryKHR(VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) const { + return _vkBindVideoSessionMemoryKHR(_device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + } + VkResult vkCreateVideoSessionParametersKHR(const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) const { + return _vkCreateVideoSessionParametersKHR(_device, pCreateInfo, pAllocator, pVideoSessionParameters); + } + VkResult vkUpdateVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const { + return _vkUpdateVideoSessionParametersKHR(_device, videoSessionParameters, pUpdateInfo); + } + void vkDestroyVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyVideoSessionParametersKHR(_device, videoSessionParameters, pAllocator); + } + void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) const { + _vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); + } + void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) const { + _vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); + } + void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) const { + _vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); + } + void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) const { + _vkCmdDecodeVideoKHR(commandBuffer, pDecodeInfo); + } + void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) const { + _vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo); + } + void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) const { + _vkCmdEndRenderingKHR(commandBuffer); + } + void vkGetDeviceGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const { + _vkGetDeviceGroupPeerMemoryFeaturesKHR(_device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + } + void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const { + _vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask); + } + void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } + void vkTrimCommandPoolKHR(VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const { + _vkTrimCommandPoolKHR(_device, commandPool, flags); + } + VkResult vkGetMemoryFdKHR(const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const { + return _vkGetMemoryFdKHR(_device, pGetFdInfo, pFd); + } + VkResult vkGetMemoryFdPropertiesKHR(VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) const { + return _vkGetMemoryFdPropertiesKHR(_device, handleType, fd, pMemoryFdProperties); + } + VkResult vkImportSemaphoreFdKHR(const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const { + return _vkImportSemaphoreFdKHR(_device, pImportSemaphoreFdInfo); + } + VkResult vkGetSemaphoreFdKHR(const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const { + return _vkGetSemaphoreFdKHR(_device, pGetFdInfo, pFd); + } + void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const { + _vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + } + void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) const { + _vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } + VkResult vkCreateDescriptorUpdateTemplateKHR(const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const { + return _vkCreateDescriptorUpdateTemplateKHR(_device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + } + void vkDestroyDescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorUpdateTemplateKHR(_device, descriptorUpdateTemplate, pAllocator); + } + void vkUpdateDescriptorSetWithTemplateKHR(VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const { + _vkUpdateDescriptorSetWithTemplateKHR(_device, descriptorSet, descriptorUpdateTemplate, pData); + } + VkResult vkCreateRenderPass2KHR(const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const { + return _vkCreateRenderPass2KHR(_device, pCreateInfo, pAllocator, pRenderPass); + } + void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) const { + _vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + } + void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + } + void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); + } + VkResult vkGetSwapchainStatusKHR(VkSwapchainKHR swapchain) const { + return _vkGetSwapchainStatusKHR(_device, swapchain); + } + VkResult vkImportFenceFdKHR(const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const { + return _vkImportFenceFdKHR(_device, pImportFenceFdInfo); + } + VkResult vkGetFenceFdKHR(const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const { + return _vkGetFenceFdKHR(_device, pGetFdInfo, pFd); + } + VkResult vkAcquireProfilingLockKHR(const VkAcquireProfilingLockInfoKHR* pInfo) const { + return _vkAcquireProfilingLockKHR(_device, pInfo); + } + void vkReleaseProfilingLockKHR() const { + _vkReleaseProfilingLockKHR(_device); + } + void vkGetImageMemoryRequirements2KHR(const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetImageMemoryRequirements2KHR(_device, pInfo, pMemoryRequirements); + } + void vkGetBufferMemoryRequirements2KHR(const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetBufferMemoryRequirements2KHR(_device, pInfo, pMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements2KHR(const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetImageSparseMemoryRequirements2KHR(_device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + VkResult vkCreateSamplerYcbcrConversionKHR(const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const { + return _vkCreateSamplerYcbcrConversionKHR(_device, pCreateInfo, pAllocator, pYcbcrConversion); + } + void vkDestroySamplerYcbcrConversionKHR(VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySamplerYcbcrConversionKHR(_device, ycbcrConversion, pAllocator); + } + VkResult vkBindBufferMemory2KHR(uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const { + return _vkBindBufferMemory2KHR(_device, bindInfoCount, pBindInfos); + } + VkResult vkBindImageMemory2KHR(uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const { + return _vkBindImageMemory2KHR(_device, bindInfoCount, pBindInfos); + } + void vkGetDescriptorSetLayoutSupportKHR(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const { + _vkGetDescriptorSetLayoutSupportKHR(_device, pCreateInfo, pSupport); + } + void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + VkResult vkGetSemaphoreCounterValueKHR(VkSemaphore semaphore, uint64_t* pValue) const { + return _vkGetSemaphoreCounterValueKHR(_device, semaphore, pValue); + } + VkResult vkWaitSemaphoresKHR(const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) const { + return _vkWaitSemaphoresKHR(_device, pWaitInfo, timeout); + } + VkResult vkSignalSemaphoreKHR(const VkSemaphoreSignalInfo* pSignalInfo) const { + return _vkSignalSemaphoreKHR(_device, pSignalInfo); + } + void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const { + _vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); + } + void vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo) const { + _vkCmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); + } + void vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo) const { + _vkCmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); + } + VkResult vkWaitForPresentKHR(VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const { + return _vkWaitForPresentKHR(_device, swapchain, presentId, timeout); + } + VkDeviceAddress vkGetBufferDeviceAddressKHR(const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferDeviceAddressKHR(_device, pInfo); + } + uint64_t vkGetBufferOpaqueCaptureAddressKHR(const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferOpaqueCaptureAddressKHR(_device, pInfo); + } + uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const { + return _vkGetDeviceMemoryOpaqueCaptureAddressKHR(_device, pInfo); + } + VkResult vkCreateDeferredOperationKHR(const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) const { + return _vkCreateDeferredOperationKHR(_device, pAllocator, pDeferredOperation); + } + void vkDestroyDeferredOperationKHR(VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDeferredOperationKHR(_device, operation, pAllocator); + } + uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDeferredOperationKHR operation) const { + return _vkGetDeferredOperationMaxConcurrencyKHR(_device, operation); + } + VkResult vkGetDeferredOperationResultKHR(VkDeferredOperationKHR operation) const { + return _vkGetDeferredOperationResultKHR(_device, operation); + } + VkResult vkDeferredOperationJoinKHR(VkDeferredOperationKHR operation) const { + return _vkDeferredOperationJoinKHR(_device, operation); + } + VkResult vkGetPipelineExecutablePropertiesKHR(const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const { + return _vkGetPipelineExecutablePropertiesKHR(_device, pPipelineInfo, pExecutableCount, pProperties); + } + VkResult vkGetPipelineExecutableStatisticsKHR(const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const { + return _vkGetPipelineExecutableStatisticsKHR(_device, pExecutableInfo, pStatisticCount, pStatistics); + } + VkResult vkGetPipelineExecutableInternalRepresentationsKHR(const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const { + return _vkGetPipelineExecutableInternalRepresentationsKHR(_device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + } + VkResult vkMapMemory2KHR(const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) const { + return _vkMapMemory2KHR(_device, pMemoryMapInfo, ppData); + } + VkResult vkUnmapMemory2KHR(const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) const { + return _vkUnmapMemory2KHR(_device, pMemoryUnmapInfo); + } + VkResult vkGetEncodedVideoSessionParametersKHR(const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) const { + return _vkGetEncodedVideoSessionParametersKHR(_device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); + } + void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const { + _vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo); + } + void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); + } + void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const { + _vkCmdResetEvent2KHR(commandBuffer, event, stageMask); + } + void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) const { + _vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); + } + void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); + } + void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const { + _vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); + } + VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) const { + return _vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence); + } + void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const { + _vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); + } + void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) const { + _vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); + } + void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) const { + _vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); + } + void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) const { + _vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo); + } + void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) const { + _vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); + } + void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) const { + _vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); + } + void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) const { + _vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo); + } + void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) const { + _vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo); + } + void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) const { + _vkCmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); + } + void vkGetDeviceBufferMemoryRequirementsKHR(const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceBufferMemoryRequirementsKHR(_device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageMemoryRequirementsKHR(const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceImageMemoryRequirementsKHR(_device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageSparseMemoryRequirementsKHR(const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetDeviceImageSparseMemoryRequirementsKHR(_device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) const { + _vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); + } + void vkGetRenderingAreaGranularityKHR(const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) const { + _vkGetRenderingAreaGranularityKHR(_device, pRenderingAreaInfo, pGranularity); + } + void vkGetDeviceImageSubresourceLayoutKHR(const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout) const { + _vkGetDeviceImageSubresourceLayoutKHR(_device, pInfo, pLayout); + } + void vkGetImageSubresourceLayout2KHR(VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout) const { + _vkGetImageSubresourceLayout2KHR(_device, image, pSubresource, pLayout); + } + void vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const { + _vkCmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); + } + VkResult vkGetCalibratedTimestampsKHR(uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const { + return _vkGetCalibratedTimestampsKHR(_device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + } + void vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) const { + _vkCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); + } + void vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo) const { + _vkCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); + } + void vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) const { + _vkCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); + } + void vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) const { + _vkCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); + } + void vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) const { + _vkCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); + } + void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) const { + _vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); + } + VkResult vkDebugMarkerSetObjectTagEXT(const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const { + return _vkDebugMarkerSetObjectTagEXT(_device, pTagInfo); + } + VkResult vkDebugMarkerSetObjectNameEXT(const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const { + return _vkDebugMarkerSetObjectNameEXT(_device, pNameInfo); + } + void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const { + _vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); + } + void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const { + _vkCmdDebugMarkerEndEXT(commandBuffer); + } + void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const { + _vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); + } + void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) const { + _vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + } + void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const { + _vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + } + void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const { + _vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + } + void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const { + _vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); + } + void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const { + _vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); + } + void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) const { + _vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + } + VkResult vkCreateCuModuleNVX(const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) const { + return _vkCreateCuModuleNVX(_device, pCreateInfo, pAllocator, pModule); + } + VkResult vkCreateCuFunctionNVX(const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) const { + return _vkCreateCuFunctionNVX(_device, pCreateInfo, pAllocator, pFunction); + } + void vkDestroyCuModuleNVX(VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCuModuleNVX(_device, module, pAllocator); + } + void vkDestroyCuFunctionNVX(VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCuFunctionNVX(_device, function, pAllocator); + } + void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) const { + _vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); + } + uint32_t vkGetImageViewHandleNVX(const VkImageViewHandleInfoNVX* pInfo) const { + return _vkGetImageViewHandleNVX(_device, pInfo); + } + VkResult vkGetImageViewAddressNVX(VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) const { + return _vkGetImageViewAddressNVX(_device, imageView, pProperties); + } + void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + VkResult vkGetShaderInfoAMD(VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) const { + return _vkGetShaderInfoAMD(_device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + } + void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const { + _vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); + } + void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const { + _vkCmdEndConditionalRenderingEXT(commandBuffer); + } + void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) const { + _vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); + } + VkResult vkDisplayPowerControlEXT(VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const { + return _vkDisplayPowerControlEXT(_device, display, pDisplayPowerInfo); + } + VkResult vkRegisterDeviceEventEXT(const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const { + return _vkRegisterDeviceEventEXT(_device, pDeviceEventInfo, pAllocator, pFence); + } + VkResult vkRegisterDisplayEventEXT(VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const { + return _vkRegisterDisplayEventEXT(_device, display, pDisplayEventInfo, pAllocator, pFence); + } + VkResult vkGetSwapchainCounterEXT(VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) const { + return _vkGetSwapchainCounterEXT(_device, swapchain, counter, pCounterValue); + } + VkResult vkGetRefreshCycleDurationGOOGLE(VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const { + return _vkGetRefreshCycleDurationGOOGLE(_device, swapchain, pDisplayTimingProperties); + } + VkResult vkGetPastPresentationTimingGOOGLE(VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) const { + return _vkGetPastPresentationTimingGOOGLE(_device, swapchain, pPresentationTimingCount, pPresentationTimings); + } + void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) const { + _vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); + } + void vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) const { + _vkCmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); + } + void vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) const { + _vkCmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); + } + void vkSetHdrMetadataEXT(uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) const { + _vkSetHdrMetadataEXT(_device, swapchainCount, pSwapchains, pMetadata); + } + VkResult vkSetDebugUtilsObjectNameEXT(const VkDebugUtilsObjectNameInfoEXT* pNameInfo) const { + return _vkSetDebugUtilsObjectNameEXT(_device, pNameInfo); + } + VkResult vkSetDebugUtilsObjectTagEXT(const VkDebugUtilsObjectTagInfoEXT* pTagInfo) const { + return _vkSetDebugUtilsObjectTagEXT(_device, pTagInfo); + } + void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); + } + void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const { + _vkQueueEndDebugUtilsLabelEXT(queue); + } + void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); + } + void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + } + void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const { + _vkCmdEndDebugUtilsLabelEXT(commandBuffer); + } + void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + } + void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const { + _vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); + } + VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) const { + return _vkGetImageDrmFormatModifierPropertiesEXT(_device, image, pProperties); + } + VkResult vkCreateValidationCacheEXT(const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) const { + return _vkCreateValidationCacheEXT(_device, pCreateInfo, pAllocator, pValidationCache); + } + void vkDestroyValidationCacheEXT(VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyValidationCacheEXT(_device, validationCache, pAllocator); + } + VkResult vkMergeValidationCachesEXT(VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) const { + return _vkMergeValidationCachesEXT(_device, dstCache, srcCacheCount, pSrcCaches); + } + VkResult vkGetValidationCacheDataEXT(VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) const { + return _vkGetValidationCacheDataEXT(_device, validationCache, pDataSize, pData); + } + void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const { + _vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); + } + void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) const { + _vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); + } + void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) const { + _vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); + } + VkResult vkCreateAccelerationStructureNV(const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) const { + return _vkCreateAccelerationStructureNV(_device, pCreateInfo, pAllocator, pAccelerationStructure); + } + void vkDestroyAccelerationStructureNV(VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyAccelerationStructureNV(_device, accelerationStructure, pAllocator); + } + void vkGetAccelerationStructureMemoryRequirementsNV(const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const { + _vkGetAccelerationStructureMemoryRequirementsNV(_device, pInfo, pMemoryRequirements); + } + VkResult vkBindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) const { + return _vkBindAccelerationStructureMemoryNV(_device, bindInfoCount, pBindInfos); + } + void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) const { + _vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); + } + void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) const { + _vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); + } + void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) const { + _vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); + } + VkResult vkCreateRayTracingPipelinesNV(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateRayTracingPipelinesNV(_device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult vkGetRayTracingShaderGroupHandlesKHR(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const { + return _vkGetRayTracingShaderGroupHandlesKHR(_device, pipeline, firstGroup, groupCount, dataSize, pData); + } + VkResult vkGetRayTracingShaderGroupHandlesNV(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const { + return _vkGetRayTracingShaderGroupHandlesNV(_device, pipeline, firstGroup, groupCount, dataSize, pData); + } + VkResult vkGetAccelerationStructureHandleNV(VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) const { + return _vkGetAccelerationStructureHandleNV(_device, accelerationStructure, dataSize, pData); + } + void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const { + _vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + } + VkResult vkCompileDeferredNV(VkPipeline pipeline, uint32_t shader) const { + return _vkCompileDeferredNV(_device, pipeline, shader); + } + VkResult vkGetMemoryHostPointerPropertiesEXT(VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) const { + return _vkGetMemoryHostPointerPropertiesEXT(_device, handleType, pHostPointer, pMemoryHostPointerProperties); + } + void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const { + _vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); + } + VkResult vkGetCalibratedTimestampsEXT(uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const { + return _vkGetCalibratedTimestampsEXT(_device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + } + void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const { + _vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); + } + void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) const { + _vkCmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); + } + void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) const { + _vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); + } + void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) const { + _vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); + } + void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) const { + _vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); + } + VkResult vkInitializePerformanceApiINTEL(const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) const { + return _vkInitializePerformanceApiINTEL(_device, pInitializeInfo); + } + void vkUninitializePerformanceApiINTEL() const { + _vkUninitializePerformanceApiINTEL(_device); + } + VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) const { + return _vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); + } + VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) const { + return _vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); + } + VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) const { + return _vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); + } + VkResult vkAcquirePerformanceConfigurationINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) const { + return _vkAcquirePerformanceConfigurationINTEL(_device, pAcquireInfo, pConfiguration); + } + VkResult vkReleasePerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL configuration) const { + return _vkReleasePerformanceConfigurationINTEL(_device, configuration); + } + VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) const { + return _vkQueueSetPerformanceConfigurationINTEL(queue, configuration); + } + VkResult vkGetPerformanceParameterINTEL(VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) const { + return _vkGetPerformanceParameterINTEL(_device, parameter, pValue); + } + void vkSetLocalDimmingAMD(VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const { + _vkSetLocalDimmingAMD(_device, swapChain, localDimmingEnable); + } + VkDeviceAddress vkGetBufferDeviceAddressEXT(const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferDeviceAddressEXT(_device, pInfo); + } + void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const { + _vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); + } + void vkResetQueryPoolEXT(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const { + _vkResetQueryPoolEXT(_device, queryPool, firstQuery, queryCount); + } + void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const { + _vkCmdSetCullModeEXT(commandBuffer, cullMode); + } + void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const { + _vkCmdSetFrontFaceEXT(commandBuffer, frontFace); + } + void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const { + _vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); + } + void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const { + _vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); + } + void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const { + _vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); + } + void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const { + _vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + } + void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const { + _vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); + } + void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const { + _vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); + } + void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const { + _vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); + } + void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const { + _vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); + } + void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const { + _vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); + } + void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const { + _vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + } + VkResult vkCopyMemoryToImageEXT(const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) const { + return _vkCopyMemoryToImageEXT(_device, pCopyMemoryToImageInfo); + } + VkResult vkCopyImageToMemoryEXT(const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) const { + return _vkCopyImageToMemoryEXT(_device, pCopyImageToMemoryInfo); + } + VkResult vkCopyImageToImageEXT(const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) const { + return _vkCopyImageToImageEXT(_device, pCopyImageToImageInfo); + } + VkResult vkTransitionImageLayoutEXT(uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT* pTransitions) const { + return _vkTransitionImageLayoutEXT(_device, transitionCount, pTransitions); + } + void vkGetImageSubresourceLayout2EXT(VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout) const { + _vkGetImageSubresourceLayout2EXT(_device, image, pSubresource, pLayout); + } + VkResult vkReleaseSwapchainImagesEXT(const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) const { + return _vkReleaseSwapchainImagesEXT(_device, pReleaseInfo); + } + void vkGetGeneratedCommandsMemoryRequirementsNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetGeneratedCommandsMemoryRequirementsNV(_device, pInfo, pMemoryRequirements); + } + void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const { + _vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); + } + void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const { + _vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); + } + void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) const { + _vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); + } + VkResult vkCreateIndirectCommandsLayoutNV(const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) const { + return _vkCreateIndirectCommandsLayoutNV(_device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + } + void vkDestroyIndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyIndirectCommandsLayoutNV(_device, indirectCommandsLayout, pAllocator); + } + void vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) const { + _vkCmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); + } + VkResult vkCreatePrivateDataSlotEXT(const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) const { + return _vkCreatePrivateDataSlotEXT(_device, pCreateInfo, pAllocator, pPrivateDataSlot); + } + void vkDestroyPrivateDataSlotEXT(VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPrivateDataSlotEXT(_device, privateDataSlot, pAllocator); + } + VkResult vkSetPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const { + return _vkSetPrivateDataEXT(_device, objectType, objectHandle, privateDataSlot, data); + } + void vkGetPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) const { + _vkGetPrivateDataEXT(_device, objectType, objectHandle, privateDataSlot, pData); + } + VkResult vkCreateCudaModuleNV(const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) const { + return _vkCreateCudaModuleNV(_device, pCreateInfo, pAllocator, pModule); + } + VkResult vkGetCudaModuleCacheNV(VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) const { + return _vkGetCudaModuleCacheNV(_device, module, pCacheSize, pCacheData); + } + VkResult vkCreateCudaFunctionNV(const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) const { + return _vkCreateCudaFunctionNV(_device, pCreateInfo, pAllocator, pFunction); + } + void vkDestroyCudaModuleNV(VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCudaModuleNV(_device, module, pAllocator); + } + void vkDestroyCudaFunctionNV(VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCudaFunctionNV(_device, function, pAllocator); + } + void vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) const { + _vkCmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); + } + void vkGetDescriptorSetLayoutSizeEXT(VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) const { + _vkGetDescriptorSetLayoutSizeEXT(_device, layout, pLayoutSizeInBytes); + } + void vkGetDescriptorSetLayoutBindingOffsetEXT(VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) const { + _vkGetDescriptorSetLayoutBindingOffsetEXT(_device, layout, binding, pOffset); + } + void vkGetDescriptorEXT(const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) const { + _vkGetDescriptorEXT(_device, pDescriptorInfo, dataSize, pDescriptor); + } + void vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) const { + _vkCmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); + } + void vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) const { + _vkCmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); + } + void vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) const { + _vkCmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); + } + VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT(const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetBufferOpaqueCaptureDescriptorDataEXT(_device, pInfo, pData); + } + VkResult vkGetImageOpaqueCaptureDescriptorDataEXT(const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetImageOpaqueCaptureDescriptorDataEXT(_device, pInfo, pData); + } + VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT(const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetImageViewOpaqueCaptureDescriptorDataEXT(_device, pInfo, pData); + } + VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT(const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetSamplerOpaqueCaptureDescriptorDataEXT(_device, pInfo, pData); + } + VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(_device, pInfo, pData); + } + void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const { + _vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); + } + VkResult vkGetDeviceFaultInfoEXT(VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) const { + return _vkGetDeviceFaultInfoEXT(_device, pFaultCounts, pFaultInfo); + } + void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) const { + _vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); + } + VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) const { + return _vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(_device, renderpass, pMaxWorkgroupSize); + } + void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const { + _vkCmdSubpassShadingHUAWEI(commandBuffer); + } + void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const { + _vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); + } + VkResult vkGetMemoryRemoteAddressNV(const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) const { + return _vkGetMemoryRemoteAddressNV(_device, pMemoryGetRemoteAddressInfo, pAddress); + } + VkResult vkGetPipelinePropertiesEXT(const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) const { + return _vkGetPipelinePropertiesEXT(_device, pPipelineInfo, pPipelineProperties); + } + void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const { + _vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); + } + void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const { + _vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); + } + void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const { + _vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); + } + void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const { + _vkCmdSetLogicOpEXT(commandBuffer, logicOp); + } + void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const { + _vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); + } + void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) const { + _vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); + } + void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) const { + _vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); + } + void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) const { + _vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); + } + VkResult vkCreateMicromapEXT(const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) const { + return _vkCreateMicromapEXT(_device, pCreateInfo, pAllocator, pMicromap); + } + void vkDestroyMicromapEXT(VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyMicromapEXT(_device, micromap, pAllocator); + } + void vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) const { + _vkCmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); + } + VkResult vkBuildMicromapsEXT(VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) const { + return _vkBuildMicromapsEXT(_device, deferredOperation, infoCount, pInfos); + } + VkResult vkCopyMicromapEXT(VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) const { + return _vkCopyMicromapEXT(_device, deferredOperation, pInfo); + } + VkResult vkCopyMicromapToMemoryEXT(VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) const { + return _vkCopyMicromapToMemoryEXT(_device, deferredOperation, pInfo); + } + VkResult vkCopyMemoryToMicromapEXT(VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) const { + return _vkCopyMemoryToMicromapEXT(_device, deferredOperation, pInfo); + } + VkResult vkWriteMicromapsPropertiesEXT(uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) const { + return _vkWriteMicromapsPropertiesEXT(_device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); + } + void vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) const { + _vkCmdCopyMicromapEXT(commandBuffer, pInfo); + } + void vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) const { + _vkCmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); + } + void vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) const { + _vkCmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); + } + void vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const { + _vkCmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); + } + void vkGetDeviceMicromapCompatibilityEXT(const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) const { + _vkGetDeviceMicromapCompatibilityEXT(_device, pVersionInfo, pCompatibility); + } + void vkGetMicromapBuildSizesEXT(VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) const { + _vkGetMicromapBuildSizesEXT(_device, buildType, pBuildInfo, pSizeInfo); + } + void vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const { + _vkCmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); + } + void vkSetDeviceMemoryPriorityEXT(VkDeviceMemory memory, float priority) const { + _vkSetDeviceMemoryPriorityEXT(_device, memory, priority); + } + void vkGetDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) const { + _vkGetDescriptorSetLayoutHostMappingInfoVALVE(_device, pBindingReference, pHostMapping); + } + void vkGetDescriptorSetHostMappingVALVE(VkDescriptorSet descriptorSet, void** ppData) const { + _vkGetDescriptorSetHostMappingVALVE(_device, descriptorSet, ppData); + } + void vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) const { + _vkCmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); + } + void vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) const { + _vkCmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); + } + void vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) const { + _vkCmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); + } + void vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) const { + _vkCmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); + } + void vkGetPipelineIndirectMemoryRequirementsNV(const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetPipelineIndirectMemoryRequirementsNV(_device, pCreateInfo, pMemoryRequirements); + } + void vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const { + _vkCmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); + } + VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV(const VkPipelineIndirectDeviceAddressInfoNV* pInfo) const { + return _vkGetPipelineIndirectDeviceAddressNV(_device, pInfo); + } + void vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) const { + _vkCmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); + } + void vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) const { + _vkCmdSetPolygonModeEXT(commandBuffer, polygonMode); + } + void vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) const { + _vkCmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); + } + void vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) const { + _vkCmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); + } + void vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) const { + _vkCmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); + } + void vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) const { + _vkCmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); + } + void vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) const { + _vkCmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); + } + void vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) const { + _vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); + } + void vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) const { + _vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); + } + void vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) const { + _vkCmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); + } + void vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) const { + _vkCmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); + } + void vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) const { + _vkCmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); + } + void vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) const { + _vkCmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); + } + void vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) const { + _vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); + } + void vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) const { + _vkCmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); + } + void vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) const { + _vkCmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); + } + void vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) const { + _vkCmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); + } + void vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) const { + _vkCmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); + } + void vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) const { + _vkCmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); + } + void vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) const { + _vkCmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); + } + void vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) const { + _vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); + } + void vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) const { + _vkCmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); + } + void vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) const { + _vkCmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); + } + void vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) const { + _vkCmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); + } + void vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) const { + _vkCmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); + } + void vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) const { + _vkCmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); + } + void vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) const { + _vkCmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); + } + void vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) const { + _vkCmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); + } + void vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) const { + _vkCmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); + } + void vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) const { + _vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); + } + void vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) const { + _vkCmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); + } + void vkGetShaderModuleIdentifierEXT(VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) const { + _vkGetShaderModuleIdentifierEXT(_device, shaderModule, pIdentifier); + } + void vkGetShaderModuleCreateInfoIdentifierEXT(const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) const { + _vkGetShaderModuleCreateInfoIdentifierEXT(_device, pCreateInfo, pIdentifier); + } + VkResult vkCreateOpticalFlowSessionNV(const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) const { + return _vkCreateOpticalFlowSessionNV(_device, pCreateInfo, pAllocator, pSession); + } + void vkDestroyOpticalFlowSessionNV(VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyOpticalFlowSessionNV(_device, session, pAllocator); + } + VkResult vkBindOpticalFlowSessionImageNV(VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) const { + return _vkBindOpticalFlowSessionImageNV(_device, session, bindingPoint, view, layout); + } + void vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) const { + _vkCmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); + } + VkResult vkCreateShadersEXT(uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) const { + return _vkCreateShadersEXT(_device, createInfoCount, pCreateInfos, pAllocator, pShaders); + } + void vkDestroyShaderEXT(VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyShaderEXT(_device, shader, pAllocator); + } + VkResult vkGetShaderBinaryDataEXT(VkShaderEXT shader, size_t* pDataSize, void* pData) const { + return _vkGetShaderBinaryDataEXT(_device, shader, pDataSize, pData); + } + void vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) const { + _vkCmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); + } + VkResult vkGetFramebufferTilePropertiesQCOM(VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) const { + return _vkGetFramebufferTilePropertiesQCOM(_device, framebuffer, pPropertiesCount, pProperties); + } + VkResult vkGetDynamicRenderingTilePropertiesQCOM(const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const { + return _vkGetDynamicRenderingTilePropertiesQCOM(_device, pRenderingInfo, pProperties); + } + VkResult vkSetLatencySleepModeNV(VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) const { + return _vkSetLatencySleepModeNV(_device, swapchain, pSleepModeInfo); + } + VkResult vkLatencySleepNV(VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) const { + return _vkLatencySleepNV(_device, swapchain, pSleepInfo); + } + void vkSetLatencyMarkerNV(VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) const { + _vkSetLatencyMarkerNV(_device, swapchain, pLatencyMarkerInfo); + } + void vkGetLatencyTimingsNV(VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) const { + _vkGetLatencyTimingsNV(_device, swapchain, pLatencyMarkerInfo); + } + void vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) const { + _vkQueueNotifyOutOfBandNV(queue, pQueueTypeInfo); + } + void vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) const { + _vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); + } + VkResult vkCreateAccelerationStructureKHR(const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { + return _vkCreateAccelerationStructureKHR(_device, pCreateInfo, pAllocator, pAccelerationStructure); + } + void vkDestroyAccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyAccelerationStructureKHR(_device, accelerationStructure, pAllocator); + } + void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const { + _vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); + } + void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) const { + _vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); + } + VkResult vkBuildAccelerationStructuresKHR(VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const { + return _vkBuildAccelerationStructuresKHR(_device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + } + VkResult vkCopyAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) const { + return _vkCopyAccelerationStructureKHR(_device, deferredOperation, pInfo); + } + VkResult vkCopyAccelerationStructureToMemoryKHR(VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const { + return _vkCopyAccelerationStructureToMemoryKHR(_device, deferredOperation, pInfo); + } + VkResult vkCopyMemoryToAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const { + return _vkCopyMemoryToAccelerationStructureKHR(_device, deferredOperation, pInfo); + } + VkResult vkWriteAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) const { + return _vkWriteAccelerationStructuresPropertiesKHR(_device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + } + void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) const { + _vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo); + } + void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const { + _vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); + } + void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const { + _vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); + } + VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) const { + return _vkGetAccelerationStructureDeviceAddressKHR(_device, pInfo); + } + void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const { + _vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + } + void vkGetDeviceAccelerationStructureCompatibilityKHR(const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) const { + _vkGetDeviceAccelerationStructureCompatibilityKHR(_device, pVersionInfo, pCompatibility); + } + void vkGetAccelerationStructureBuildSizesKHR(VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) const { + _vkGetAccelerationStructureBuildSizesKHR(_device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); + } + void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) const { + _vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); + } + VkResult vkCreateRayTracingPipelinesKHR(VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateRayTracingPipelinesKHR(_device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const { + return _vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(_device, pipeline, firstGroup, groupCount, dataSize, pData); + } + void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) const { + _vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); + } + VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) const { + return _vkGetRayTracingShaderGroupStackSizeKHR(_device, pipeline, group, groupShader); + } + void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const { + _vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); + } + void vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + +private: + PFN_vkDestroyDevice _vkDestroyDevice; + PFN_vkGetDeviceQueue _vkGetDeviceQueue; + PFN_vkQueueSubmit _vkQueueSubmit; + PFN_vkQueueWaitIdle _vkQueueWaitIdle; + PFN_vkDeviceWaitIdle _vkDeviceWaitIdle; + PFN_vkAllocateMemory _vkAllocateMemory; + PFN_vkFreeMemory _vkFreeMemory; + PFN_vkMapMemory _vkMapMemory; + PFN_vkUnmapMemory _vkUnmapMemory; + PFN_vkFlushMappedMemoryRanges _vkFlushMappedMemoryRanges; + PFN_vkInvalidateMappedMemoryRanges _vkInvalidateMappedMemoryRanges; + PFN_vkGetDeviceMemoryCommitment _vkGetDeviceMemoryCommitment; + PFN_vkBindBufferMemory _vkBindBufferMemory; + PFN_vkBindImageMemory _vkBindImageMemory; + PFN_vkGetBufferMemoryRequirements _vkGetBufferMemoryRequirements; + PFN_vkGetImageMemoryRequirements _vkGetImageMemoryRequirements; + PFN_vkGetImageSparseMemoryRequirements _vkGetImageSparseMemoryRequirements; + PFN_vkQueueBindSparse _vkQueueBindSparse; + PFN_vkCreateFence _vkCreateFence; + PFN_vkDestroyFence _vkDestroyFence; + PFN_vkResetFences _vkResetFences; + PFN_vkGetFenceStatus _vkGetFenceStatus; + PFN_vkWaitForFences _vkWaitForFences; + PFN_vkCreateSemaphore _vkCreateSemaphore; + PFN_vkDestroySemaphore _vkDestroySemaphore; + PFN_vkCreateEvent _vkCreateEvent; + PFN_vkDestroyEvent _vkDestroyEvent; + PFN_vkGetEventStatus _vkGetEventStatus; + PFN_vkSetEvent _vkSetEvent; + PFN_vkResetEvent _vkResetEvent; + PFN_vkCreateQueryPool _vkCreateQueryPool; + PFN_vkDestroyQueryPool _vkDestroyQueryPool; + PFN_vkGetQueryPoolResults _vkGetQueryPoolResults; + PFN_vkCreateBuffer _vkCreateBuffer; + PFN_vkDestroyBuffer _vkDestroyBuffer; + PFN_vkCreateBufferView _vkCreateBufferView; + PFN_vkDestroyBufferView _vkDestroyBufferView; + PFN_vkCreateImage _vkCreateImage; + PFN_vkDestroyImage _vkDestroyImage; + PFN_vkGetImageSubresourceLayout _vkGetImageSubresourceLayout; + PFN_vkCreateImageView _vkCreateImageView; + PFN_vkDestroyImageView _vkDestroyImageView; + PFN_vkCreateShaderModule _vkCreateShaderModule; + PFN_vkDestroyShaderModule _vkDestroyShaderModule; + PFN_vkCreatePipelineCache _vkCreatePipelineCache; + PFN_vkDestroyPipelineCache _vkDestroyPipelineCache; + PFN_vkGetPipelineCacheData _vkGetPipelineCacheData; + PFN_vkMergePipelineCaches _vkMergePipelineCaches; + PFN_vkCreateGraphicsPipelines _vkCreateGraphicsPipelines; + PFN_vkCreateComputePipelines _vkCreateComputePipelines; + PFN_vkDestroyPipeline _vkDestroyPipeline; + PFN_vkCreatePipelineLayout _vkCreatePipelineLayout; + PFN_vkDestroyPipelineLayout _vkDestroyPipelineLayout; + PFN_vkCreateSampler _vkCreateSampler; + PFN_vkDestroySampler _vkDestroySampler; + PFN_vkCreateDescriptorSetLayout _vkCreateDescriptorSetLayout; + PFN_vkDestroyDescriptorSetLayout _vkDestroyDescriptorSetLayout; + PFN_vkCreateDescriptorPool _vkCreateDescriptorPool; + PFN_vkDestroyDescriptorPool _vkDestroyDescriptorPool; + PFN_vkResetDescriptorPool _vkResetDescriptorPool; + PFN_vkAllocateDescriptorSets _vkAllocateDescriptorSets; + PFN_vkFreeDescriptorSets _vkFreeDescriptorSets; + PFN_vkUpdateDescriptorSets _vkUpdateDescriptorSets; + PFN_vkCreateFramebuffer _vkCreateFramebuffer; + PFN_vkDestroyFramebuffer _vkDestroyFramebuffer; + PFN_vkCreateRenderPass _vkCreateRenderPass; + PFN_vkDestroyRenderPass _vkDestroyRenderPass; + PFN_vkGetRenderAreaGranularity _vkGetRenderAreaGranularity; + PFN_vkCreateCommandPool _vkCreateCommandPool; + PFN_vkDestroyCommandPool _vkDestroyCommandPool; + PFN_vkResetCommandPool _vkResetCommandPool; + PFN_vkAllocateCommandBuffers _vkAllocateCommandBuffers; + PFN_vkFreeCommandBuffers _vkFreeCommandBuffers; + PFN_vkBeginCommandBuffer _vkBeginCommandBuffer; + PFN_vkEndCommandBuffer _vkEndCommandBuffer; + PFN_vkResetCommandBuffer _vkResetCommandBuffer; + PFN_vkCmdBindPipeline _vkCmdBindPipeline; + PFN_vkCmdSetViewport _vkCmdSetViewport; + PFN_vkCmdSetScissor _vkCmdSetScissor; + PFN_vkCmdSetLineWidth _vkCmdSetLineWidth; + PFN_vkCmdSetDepthBias _vkCmdSetDepthBias; + PFN_vkCmdSetBlendConstants _vkCmdSetBlendConstants; + PFN_vkCmdSetDepthBounds _vkCmdSetDepthBounds; + PFN_vkCmdSetStencilCompareMask _vkCmdSetStencilCompareMask; + PFN_vkCmdSetStencilWriteMask _vkCmdSetStencilWriteMask; + PFN_vkCmdSetStencilReference _vkCmdSetStencilReference; + PFN_vkCmdBindDescriptorSets _vkCmdBindDescriptorSets; + PFN_vkCmdBindIndexBuffer _vkCmdBindIndexBuffer; + PFN_vkCmdBindVertexBuffers _vkCmdBindVertexBuffers; + PFN_vkCmdDraw _vkCmdDraw; + PFN_vkCmdDrawIndexed _vkCmdDrawIndexed; + PFN_vkCmdDrawIndirect _vkCmdDrawIndirect; + PFN_vkCmdDrawIndexedIndirect _vkCmdDrawIndexedIndirect; + PFN_vkCmdDispatch _vkCmdDispatch; + PFN_vkCmdDispatchIndirect _vkCmdDispatchIndirect; + PFN_vkCmdCopyBuffer _vkCmdCopyBuffer; + PFN_vkCmdCopyImage _vkCmdCopyImage; + PFN_vkCmdBlitImage _vkCmdBlitImage; + PFN_vkCmdCopyBufferToImage _vkCmdCopyBufferToImage; + PFN_vkCmdCopyImageToBuffer _vkCmdCopyImageToBuffer; + PFN_vkCmdUpdateBuffer _vkCmdUpdateBuffer; + PFN_vkCmdFillBuffer _vkCmdFillBuffer; + PFN_vkCmdClearColorImage _vkCmdClearColorImage; + PFN_vkCmdClearDepthStencilImage _vkCmdClearDepthStencilImage; + PFN_vkCmdClearAttachments _vkCmdClearAttachments; + PFN_vkCmdResolveImage _vkCmdResolveImage; + PFN_vkCmdSetEvent _vkCmdSetEvent; + PFN_vkCmdResetEvent _vkCmdResetEvent; + PFN_vkCmdWaitEvents _vkCmdWaitEvents; + PFN_vkCmdPipelineBarrier _vkCmdPipelineBarrier; + PFN_vkCmdBeginQuery _vkCmdBeginQuery; + PFN_vkCmdEndQuery _vkCmdEndQuery; + PFN_vkCmdResetQueryPool _vkCmdResetQueryPool; + PFN_vkCmdWriteTimestamp _vkCmdWriteTimestamp; + PFN_vkCmdCopyQueryPoolResults _vkCmdCopyQueryPoolResults; + PFN_vkCmdPushConstants _vkCmdPushConstants; + PFN_vkCmdBeginRenderPass _vkCmdBeginRenderPass; + PFN_vkCmdNextSubpass _vkCmdNextSubpass; + PFN_vkCmdEndRenderPass _vkCmdEndRenderPass; + PFN_vkCmdExecuteCommands _vkCmdExecuteCommands; + PFN_vkBindBufferMemory2 _vkBindBufferMemory2; + PFN_vkBindImageMemory2 _vkBindImageMemory2; + PFN_vkGetDeviceGroupPeerMemoryFeatures _vkGetDeviceGroupPeerMemoryFeatures; + PFN_vkCmdSetDeviceMask _vkCmdSetDeviceMask; + PFN_vkCmdDispatchBase _vkCmdDispatchBase; + PFN_vkGetImageMemoryRequirements2 _vkGetImageMemoryRequirements2; + PFN_vkGetBufferMemoryRequirements2 _vkGetBufferMemoryRequirements2; + PFN_vkGetImageSparseMemoryRequirements2 _vkGetImageSparseMemoryRequirements2; + PFN_vkTrimCommandPool _vkTrimCommandPool; + PFN_vkGetDeviceQueue2 _vkGetDeviceQueue2; + PFN_vkCreateSamplerYcbcrConversion _vkCreateSamplerYcbcrConversion; + PFN_vkDestroySamplerYcbcrConversion _vkDestroySamplerYcbcrConversion; + PFN_vkCreateDescriptorUpdateTemplate _vkCreateDescriptorUpdateTemplate; + PFN_vkDestroyDescriptorUpdateTemplate _vkDestroyDescriptorUpdateTemplate; + PFN_vkUpdateDescriptorSetWithTemplate _vkUpdateDescriptorSetWithTemplate; + PFN_vkGetDescriptorSetLayoutSupport _vkGetDescriptorSetLayoutSupport; + PFN_vkCmdDrawIndirectCount _vkCmdDrawIndirectCount; + PFN_vkCmdDrawIndexedIndirectCount _vkCmdDrawIndexedIndirectCount; + PFN_vkCreateRenderPass2 _vkCreateRenderPass2; + PFN_vkCmdBeginRenderPass2 _vkCmdBeginRenderPass2; + PFN_vkCmdNextSubpass2 _vkCmdNextSubpass2; + PFN_vkCmdEndRenderPass2 _vkCmdEndRenderPass2; + PFN_vkResetQueryPool _vkResetQueryPool; + PFN_vkGetSemaphoreCounterValue _vkGetSemaphoreCounterValue; + PFN_vkWaitSemaphores _vkWaitSemaphores; + PFN_vkSignalSemaphore _vkSignalSemaphore; + PFN_vkGetBufferDeviceAddress _vkGetBufferDeviceAddress; + PFN_vkGetBufferOpaqueCaptureAddress _vkGetBufferOpaqueCaptureAddress; + PFN_vkGetDeviceMemoryOpaqueCaptureAddress _vkGetDeviceMemoryOpaqueCaptureAddress; + PFN_vkCreatePrivateDataSlot _vkCreatePrivateDataSlot; + PFN_vkDestroyPrivateDataSlot _vkDestroyPrivateDataSlot; + PFN_vkSetPrivateData _vkSetPrivateData; + PFN_vkGetPrivateData _vkGetPrivateData; + PFN_vkCmdSetEvent2 _vkCmdSetEvent2; + PFN_vkCmdResetEvent2 _vkCmdResetEvent2; + PFN_vkCmdWaitEvents2 _vkCmdWaitEvents2; + PFN_vkCmdPipelineBarrier2 _vkCmdPipelineBarrier2; + PFN_vkCmdWriteTimestamp2 _vkCmdWriteTimestamp2; + PFN_vkQueueSubmit2 _vkQueueSubmit2; + PFN_vkCmdCopyBuffer2 _vkCmdCopyBuffer2; + PFN_vkCmdCopyImage2 _vkCmdCopyImage2; + PFN_vkCmdCopyBufferToImage2 _vkCmdCopyBufferToImage2; + PFN_vkCmdCopyImageToBuffer2 _vkCmdCopyImageToBuffer2; + PFN_vkCmdBlitImage2 _vkCmdBlitImage2; + PFN_vkCmdResolveImage2 _vkCmdResolveImage2; + PFN_vkCmdBeginRendering _vkCmdBeginRendering; + PFN_vkCmdEndRendering _vkCmdEndRendering; + PFN_vkCmdSetCullMode _vkCmdSetCullMode; + PFN_vkCmdSetFrontFace _vkCmdSetFrontFace; + PFN_vkCmdSetPrimitiveTopology _vkCmdSetPrimitiveTopology; + PFN_vkCmdSetViewportWithCount _vkCmdSetViewportWithCount; + PFN_vkCmdSetScissorWithCount _vkCmdSetScissorWithCount; + PFN_vkCmdBindVertexBuffers2 _vkCmdBindVertexBuffers2; + PFN_vkCmdSetDepthTestEnable _vkCmdSetDepthTestEnable; + PFN_vkCmdSetDepthWriteEnable _vkCmdSetDepthWriteEnable; + PFN_vkCmdSetDepthCompareOp _vkCmdSetDepthCompareOp; + PFN_vkCmdSetDepthBoundsTestEnable _vkCmdSetDepthBoundsTestEnable; + PFN_vkCmdSetStencilTestEnable _vkCmdSetStencilTestEnable; + PFN_vkCmdSetStencilOp _vkCmdSetStencilOp; + PFN_vkCmdSetRasterizerDiscardEnable _vkCmdSetRasterizerDiscardEnable; + PFN_vkCmdSetDepthBiasEnable _vkCmdSetDepthBiasEnable; + PFN_vkCmdSetPrimitiveRestartEnable _vkCmdSetPrimitiveRestartEnable; + PFN_vkGetDeviceBufferMemoryRequirements _vkGetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceImageMemoryRequirements _vkGetDeviceImageMemoryRequirements; + PFN_vkGetDeviceImageSparseMemoryRequirements _vkGetDeviceImageSparseMemoryRequirements; + PFN_vkCreateSwapchainKHR _vkCreateSwapchainKHR; + PFN_vkDestroySwapchainKHR _vkDestroySwapchainKHR; + PFN_vkGetSwapchainImagesKHR _vkGetSwapchainImagesKHR; + PFN_vkAcquireNextImageKHR _vkAcquireNextImageKHR; + PFN_vkQueuePresentKHR _vkQueuePresentKHR; + PFN_vkGetDeviceGroupPresentCapabilitiesKHR _vkGetDeviceGroupPresentCapabilitiesKHR; + PFN_vkGetDeviceGroupSurfacePresentModesKHR _vkGetDeviceGroupSurfacePresentModesKHR; + PFN_vkAcquireNextImage2KHR _vkAcquireNextImage2KHR; + PFN_vkCreateSharedSwapchainsKHR _vkCreateSharedSwapchainsKHR; + PFN_vkCreateVideoSessionKHR _vkCreateVideoSessionKHR; + PFN_vkDestroyVideoSessionKHR _vkDestroyVideoSessionKHR; + PFN_vkGetVideoSessionMemoryRequirementsKHR _vkGetVideoSessionMemoryRequirementsKHR; + PFN_vkBindVideoSessionMemoryKHR _vkBindVideoSessionMemoryKHR; + PFN_vkCreateVideoSessionParametersKHR _vkCreateVideoSessionParametersKHR; + PFN_vkUpdateVideoSessionParametersKHR _vkUpdateVideoSessionParametersKHR; + PFN_vkDestroyVideoSessionParametersKHR _vkDestroyVideoSessionParametersKHR; + PFN_vkCmdBeginVideoCodingKHR _vkCmdBeginVideoCodingKHR; + PFN_vkCmdEndVideoCodingKHR _vkCmdEndVideoCodingKHR; + PFN_vkCmdControlVideoCodingKHR _vkCmdControlVideoCodingKHR; + PFN_vkCmdDecodeVideoKHR _vkCmdDecodeVideoKHR; + PFN_vkCmdBeginRenderingKHR _vkCmdBeginRenderingKHR; + PFN_vkCmdEndRenderingKHR _vkCmdEndRenderingKHR; + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR _vkGetDeviceGroupPeerMemoryFeaturesKHR; + PFN_vkCmdSetDeviceMaskKHR _vkCmdSetDeviceMaskKHR; + PFN_vkCmdDispatchBaseKHR _vkCmdDispatchBaseKHR; + PFN_vkTrimCommandPoolKHR _vkTrimCommandPoolKHR; + PFN_vkGetMemoryFdKHR _vkGetMemoryFdKHR; + PFN_vkGetMemoryFdPropertiesKHR _vkGetMemoryFdPropertiesKHR; + PFN_vkImportSemaphoreFdKHR _vkImportSemaphoreFdKHR; + PFN_vkGetSemaphoreFdKHR _vkGetSemaphoreFdKHR; + PFN_vkCmdPushDescriptorSetKHR _vkCmdPushDescriptorSetKHR; + PFN_vkCmdPushDescriptorSetWithTemplateKHR _vkCmdPushDescriptorSetWithTemplateKHR; + PFN_vkCreateDescriptorUpdateTemplateKHR _vkCreateDescriptorUpdateTemplateKHR; + PFN_vkDestroyDescriptorUpdateTemplateKHR _vkDestroyDescriptorUpdateTemplateKHR; + PFN_vkUpdateDescriptorSetWithTemplateKHR _vkUpdateDescriptorSetWithTemplateKHR; + PFN_vkCreateRenderPass2KHR _vkCreateRenderPass2KHR; + PFN_vkCmdBeginRenderPass2KHR _vkCmdBeginRenderPass2KHR; + PFN_vkCmdNextSubpass2KHR _vkCmdNextSubpass2KHR; + PFN_vkCmdEndRenderPass2KHR _vkCmdEndRenderPass2KHR; + PFN_vkGetSwapchainStatusKHR _vkGetSwapchainStatusKHR; + PFN_vkImportFenceFdKHR _vkImportFenceFdKHR; + PFN_vkGetFenceFdKHR _vkGetFenceFdKHR; + PFN_vkAcquireProfilingLockKHR _vkAcquireProfilingLockKHR; + PFN_vkReleaseProfilingLockKHR _vkReleaseProfilingLockKHR; + PFN_vkGetImageMemoryRequirements2KHR _vkGetImageMemoryRequirements2KHR; + PFN_vkGetBufferMemoryRequirements2KHR _vkGetBufferMemoryRequirements2KHR; + PFN_vkGetImageSparseMemoryRequirements2KHR _vkGetImageSparseMemoryRequirements2KHR; + PFN_vkCreateSamplerYcbcrConversionKHR _vkCreateSamplerYcbcrConversionKHR; + PFN_vkDestroySamplerYcbcrConversionKHR _vkDestroySamplerYcbcrConversionKHR; + PFN_vkBindBufferMemory2KHR _vkBindBufferMemory2KHR; + PFN_vkBindImageMemory2KHR _vkBindImageMemory2KHR; + PFN_vkGetDescriptorSetLayoutSupportKHR _vkGetDescriptorSetLayoutSupportKHR; + PFN_vkCmdDrawIndirectCountKHR _vkCmdDrawIndirectCountKHR; + PFN_vkCmdDrawIndexedIndirectCountKHR _vkCmdDrawIndexedIndirectCountKHR; + PFN_vkGetSemaphoreCounterValueKHR _vkGetSemaphoreCounterValueKHR; + PFN_vkWaitSemaphoresKHR _vkWaitSemaphoresKHR; + PFN_vkSignalSemaphoreKHR _vkSignalSemaphoreKHR; + PFN_vkCmdSetFragmentShadingRateKHR _vkCmdSetFragmentShadingRateKHR; + PFN_vkCmdSetRenderingAttachmentLocationsKHR _vkCmdSetRenderingAttachmentLocationsKHR; + PFN_vkCmdSetRenderingInputAttachmentIndicesKHR _vkCmdSetRenderingInputAttachmentIndicesKHR; + PFN_vkWaitForPresentKHR _vkWaitForPresentKHR; + PFN_vkGetBufferDeviceAddressKHR _vkGetBufferDeviceAddressKHR; + PFN_vkGetBufferOpaqueCaptureAddressKHR _vkGetBufferOpaqueCaptureAddressKHR; + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR _vkGetDeviceMemoryOpaqueCaptureAddressKHR; + PFN_vkCreateDeferredOperationKHR _vkCreateDeferredOperationKHR; + PFN_vkDestroyDeferredOperationKHR _vkDestroyDeferredOperationKHR; + PFN_vkGetDeferredOperationMaxConcurrencyKHR _vkGetDeferredOperationMaxConcurrencyKHR; + PFN_vkGetDeferredOperationResultKHR _vkGetDeferredOperationResultKHR; + PFN_vkDeferredOperationJoinKHR _vkDeferredOperationJoinKHR; + PFN_vkGetPipelineExecutablePropertiesKHR _vkGetPipelineExecutablePropertiesKHR; + PFN_vkGetPipelineExecutableStatisticsKHR _vkGetPipelineExecutableStatisticsKHR; + PFN_vkGetPipelineExecutableInternalRepresentationsKHR _vkGetPipelineExecutableInternalRepresentationsKHR; + PFN_vkMapMemory2KHR _vkMapMemory2KHR; + PFN_vkUnmapMemory2KHR _vkUnmapMemory2KHR; + PFN_vkGetEncodedVideoSessionParametersKHR _vkGetEncodedVideoSessionParametersKHR; + PFN_vkCmdEncodeVideoKHR _vkCmdEncodeVideoKHR; + PFN_vkCmdSetEvent2KHR _vkCmdSetEvent2KHR; + PFN_vkCmdResetEvent2KHR _vkCmdResetEvent2KHR; + PFN_vkCmdWaitEvents2KHR _vkCmdWaitEvents2KHR; + PFN_vkCmdPipelineBarrier2KHR _vkCmdPipelineBarrier2KHR; + PFN_vkCmdWriteTimestamp2KHR _vkCmdWriteTimestamp2KHR; + PFN_vkQueueSubmit2KHR _vkQueueSubmit2KHR; + PFN_vkCmdWriteBufferMarker2AMD _vkCmdWriteBufferMarker2AMD; + PFN_vkGetQueueCheckpointData2NV _vkGetQueueCheckpointData2NV; + PFN_vkCmdCopyBuffer2KHR _vkCmdCopyBuffer2KHR; + PFN_vkCmdCopyImage2KHR _vkCmdCopyImage2KHR; + PFN_vkCmdCopyBufferToImage2KHR _vkCmdCopyBufferToImage2KHR; + PFN_vkCmdCopyImageToBuffer2KHR _vkCmdCopyImageToBuffer2KHR; + PFN_vkCmdBlitImage2KHR _vkCmdBlitImage2KHR; + PFN_vkCmdResolveImage2KHR _vkCmdResolveImage2KHR; + PFN_vkCmdTraceRaysIndirect2KHR _vkCmdTraceRaysIndirect2KHR; + PFN_vkGetDeviceBufferMemoryRequirementsKHR _vkGetDeviceBufferMemoryRequirementsKHR; + PFN_vkGetDeviceImageMemoryRequirementsKHR _vkGetDeviceImageMemoryRequirementsKHR; + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR _vkGetDeviceImageSparseMemoryRequirementsKHR; + PFN_vkCmdBindIndexBuffer2KHR _vkCmdBindIndexBuffer2KHR; + PFN_vkGetRenderingAreaGranularityKHR _vkGetRenderingAreaGranularityKHR; + PFN_vkGetDeviceImageSubresourceLayoutKHR _vkGetDeviceImageSubresourceLayoutKHR; + PFN_vkGetImageSubresourceLayout2KHR _vkGetImageSubresourceLayout2KHR; + PFN_vkCmdSetLineStippleKHR _vkCmdSetLineStippleKHR; + PFN_vkGetCalibratedTimestampsKHR _vkGetCalibratedTimestampsKHR; + PFN_vkCmdBindDescriptorSets2KHR _vkCmdBindDescriptorSets2KHR; + PFN_vkCmdPushConstants2KHR _vkCmdPushConstants2KHR; + PFN_vkCmdPushDescriptorSet2KHR _vkCmdPushDescriptorSet2KHR; + PFN_vkCmdPushDescriptorSetWithTemplate2KHR _vkCmdPushDescriptorSetWithTemplate2KHR; + PFN_vkCmdSetDescriptorBufferOffsets2EXT _vkCmdSetDescriptorBufferOffsets2EXT; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT _vkCmdBindDescriptorBufferEmbeddedSamplers2EXT; + PFN_vkDebugMarkerSetObjectTagEXT _vkDebugMarkerSetObjectTagEXT; + PFN_vkDebugMarkerSetObjectNameEXT _vkDebugMarkerSetObjectNameEXT; + PFN_vkCmdDebugMarkerBeginEXT _vkCmdDebugMarkerBeginEXT; + PFN_vkCmdDebugMarkerEndEXT _vkCmdDebugMarkerEndEXT; + PFN_vkCmdDebugMarkerInsertEXT _vkCmdDebugMarkerInsertEXT; + PFN_vkCmdBindTransformFeedbackBuffersEXT _vkCmdBindTransformFeedbackBuffersEXT; + PFN_vkCmdBeginTransformFeedbackEXT _vkCmdBeginTransformFeedbackEXT; + PFN_vkCmdEndTransformFeedbackEXT _vkCmdEndTransformFeedbackEXT; + PFN_vkCmdBeginQueryIndexedEXT _vkCmdBeginQueryIndexedEXT; + PFN_vkCmdEndQueryIndexedEXT _vkCmdEndQueryIndexedEXT; + PFN_vkCmdDrawIndirectByteCountEXT _vkCmdDrawIndirectByteCountEXT; + PFN_vkCreateCuModuleNVX _vkCreateCuModuleNVX; + PFN_vkCreateCuFunctionNVX _vkCreateCuFunctionNVX; + PFN_vkDestroyCuModuleNVX _vkDestroyCuModuleNVX; + PFN_vkDestroyCuFunctionNVX _vkDestroyCuFunctionNVX; + PFN_vkCmdCuLaunchKernelNVX _vkCmdCuLaunchKernelNVX; + PFN_vkGetImageViewHandleNVX _vkGetImageViewHandleNVX; + PFN_vkGetImageViewAddressNVX _vkGetImageViewAddressNVX; + PFN_vkCmdDrawIndirectCountAMD _vkCmdDrawIndirectCountAMD; + PFN_vkCmdDrawIndexedIndirectCountAMD _vkCmdDrawIndexedIndirectCountAMD; + PFN_vkGetShaderInfoAMD _vkGetShaderInfoAMD; + PFN_vkCmdBeginConditionalRenderingEXT _vkCmdBeginConditionalRenderingEXT; + PFN_vkCmdEndConditionalRenderingEXT _vkCmdEndConditionalRenderingEXT; + PFN_vkCmdSetViewportWScalingNV _vkCmdSetViewportWScalingNV; + PFN_vkDisplayPowerControlEXT _vkDisplayPowerControlEXT; + PFN_vkRegisterDeviceEventEXT _vkRegisterDeviceEventEXT; + PFN_vkRegisterDisplayEventEXT _vkRegisterDisplayEventEXT; + PFN_vkGetSwapchainCounterEXT _vkGetSwapchainCounterEXT; + PFN_vkGetRefreshCycleDurationGOOGLE _vkGetRefreshCycleDurationGOOGLE; + PFN_vkGetPastPresentationTimingGOOGLE _vkGetPastPresentationTimingGOOGLE; + PFN_vkCmdSetDiscardRectangleEXT _vkCmdSetDiscardRectangleEXT; + PFN_vkCmdSetDiscardRectangleEnableEXT _vkCmdSetDiscardRectangleEnableEXT; + PFN_vkCmdSetDiscardRectangleModeEXT _vkCmdSetDiscardRectangleModeEXT; + PFN_vkSetHdrMetadataEXT _vkSetHdrMetadataEXT; + PFN_vkSetDebugUtilsObjectNameEXT _vkSetDebugUtilsObjectNameEXT; + PFN_vkSetDebugUtilsObjectTagEXT _vkSetDebugUtilsObjectTagEXT; + PFN_vkQueueBeginDebugUtilsLabelEXT _vkQueueBeginDebugUtilsLabelEXT; + PFN_vkQueueEndDebugUtilsLabelEXT _vkQueueEndDebugUtilsLabelEXT; + PFN_vkQueueInsertDebugUtilsLabelEXT _vkQueueInsertDebugUtilsLabelEXT; + PFN_vkCmdBeginDebugUtilsLabelEXT _vkCmdBeginDebugUtilsLabelEXT; + PFN_vkCmdEndDebugUtilsLabelEXT _vkCmdEndDebugUtilsLabelEXT; + PFN_vkCmdInsertDebugUtilsLabelEXT _vkCmdInsertDebugUtilsLabelEXT; + PFN_vkCmdSetSampleLocationsEXT _vkCmdSetSampleLocationsEXT; + PFN_vkGetImageDrmFormatModifierPropertiesEXT _vkGetImageDrmFormatModifierPropertiesEXT; + PFN_vkCreateValidationCacheEXT _vkCreateValidationCacheEXT; + PFN_vkDestroyValidationCacheEXT _vkDestroyValidationCacheEXT; + PFN_vkMergeValidationCachesEXT _vkMergeValidationCachesEXT; + PFN_vkGetValidationCacheDataEXT _vkGetValidationCacheDataEXT; + PFN_vkCmdBindShadingRateImageNV _vkCmdBindShadingRateImageNV; + PFN_vkCmdSetViewportShadingRatePaletteNV _vkCmdSetViewportShadingRatePaletteNV; + PFN_vkCmdSetCoarseSampleOrderNV _vkCmdSetCoarseSampleOrderNV; + PFN_vkCreateAccelerationStructureNV _vkCreateAccelerationStructureNV; + PFN_vkDestroyAccelerationStructureNV _vkDestroyAccelerationStructureNV; + PFN_vkGetAccelerationStructureMemoryRequirementsNV _vkGetAccelerationStructureMemoryRequirementsNV; + PFN_vkBindAccelerationStructureMemoryNV _vkBindAccelerationStructureMemoryNV; + PFN_vkCmdBuildAccelerationStructureNV _vkCmdBuildAccelerationStructureNV; + PFN_vkCmdCopyAccelerationStructureNV _vkCmdCopyAccelerationStructureNV; + PFN_vkCmdTraceRaysNV _vkCmdTraceRaysNV; + PFN_vkCreateRayTracingPipelinesNV _vkCreateRayTracingPipelinesNV; + PFN_vkGetRayTracingShaderGroupHandlesKHR _vkGetRayTracingShaderGroupHandlesKHR; + PFN_vkGetRayTracingShaderGroupHandlesNV _vkGetRayTracingShaderGroupHandlesNV; + PFN_vkGetAccelerationStructureHandleNV _vkGetAccelerationStructureHandleNV; + PFN_vkCmdWriteAccelerationStructuresPropertiesNV _vkCmdWriteAccelerationStructuresPropertiesNV; + PFN_vkCompileDeferredNV _vkCompileDeferredNV; + PFN_vkGetMemoryHostPointerPropertiesEXT _vkGetMemoryHostPointerPropertiesEXT; + PFN_vkCmdWriteBufferMarkerAMD _vkCmdWriteBufferMarkerAMD; + PFN_vkGetCalibratedTimestampsEXT _vkGetCalibratedTimestampsEXT; + PFN_vkCmdDrawMeshTasksNV _vkCmdDrawMeshTasksNV; + PFN_vkCmdDrawMeshTasksIndirectNV _vkCmdDrawMeshTasksIndirectNV; + PFN_vkCmdDrawMeshTasksIndirectCountNV _vkCmdDrawMeshTasksIndirectCountNV; + PFN_vkCmdSetExclusiveScissorEnableNV _vkCmdSetExclusiveScissorEnableNV; + PFN_vkCmdSetExclusiveScissorNV _vkCmdSetExclusiveScissorNV; + PFN_vkCmdSetCheckpointNV _vkCmdSetCheckpointNV; + PFN_vkGetQueueCheckpointDataNV _vkGetQueueCheckpointDataNV; + PFN_vkInitializePerformanceApiINTEL _vkInitializePerformanceApiINTEL; + PFN_vkUninitializePerformanceApiINTEL _vkUninitializePerformanceApiINTEL; + PFN_vkCmdSetPerformanceMarkerINTEL _vkCmdSetPerformanceMarkerINTEL; + PFN_vkCmdSetPerformanceStreamMarkerINTEL _vkCmdSetPerformanceStreamMarkerINTEL; + PFN_vkCmdSetPerformanceOverrideINTEL _vkCmdSetPerformanceOverrideINTEL; + PFN_vkAcquirePerformanceConfigurationINTEL _vkAcquirePerformanceConfigurationINTEL; + PFN_vkReleasePerformanceConfigurationINTEL _vkReleasePerformanceConfigurationINTEL; + PFN_vkQueueSetPerformanceConfigurationINTEL _vkQueueSetPerformanceConfigurationINTEL; + PFN_vkGetPerformanceParameterINTEL _vkGetPerformanceParameterINTEL; + PFN_vkSetLocalDimmingAMD _vkSetLocalDimmingAMD; + PFN_vkGetBufferDeviceAddressEXT _vkGetBufferDeviceAddressEXT; + PFN_vkCmdSetLineStippleEXT _vkCmdSetLineStippleEXT; + PFN_vkResetQueryPoolEXT _vkResetQueryPoolEXT; + PFN_vkCmdSetCullModeEXT _vkCmdSetCullModeEXT; + PFN_vkCmdSetFrontFaceEXT _vkCmdSetFrontFaceEXT; + PFN_vkCmdSetPrimitiveTopologyEXT _vkCmdSetPrimitiveTopologyEXT; + PFN_vkCmdSetViewportWithCountEXT _vkCmdSetViewportWithCountEXT; + PFN_vkCmdSetScissorWithCountEXT _vkCmdSetScissorWithCountEXT; + PFN_vkCmdBindVertexBuffers2EXT _vkCmdBindVertexBuffers2EXT; + PFN_vkCmdSetDepthTestEnableEXT _vkCmdSetDepthTestEnableEXT; + PFN_vkCmdSetDepthWriteEnableEXT _vkCmdSetDepthWriteEnableEXT; + PFN_vkCmdSetDepthCompareOpEXT _vkCmdSetDepthCompareOpEXT; + PFN_vkCmdSetDepthBoundsTestEnableEXT _vkCmdSetDepthBoundsTestEnableEXT; + PFN_vkCmdSetStencilTestEnableEXT _vkCmdSetStencilTestEnableEXT; + PFN_vkCmdSetStencilOpEXT _vkCmdSetStencilOpEXT; + PFN_vkCopyMemoryToImageEXT _vkCopyMemoryToImageEXT; + PFN_vkCopyImageToMemoryEXT _vkCopyImageToMemoryEXT; + PFN_vkCopyImageToImageEXT _vkCopyImageToImageEXT; + PFN_vkTransitionImageLayoutEXT _vkTransitionImageLayoutEXT; + PFN_vkGetImageSubresourceLayout2EXT _vkGetImageSubresourceLayout2EXT; + PFN_vkReleaseSwapchainImagesEXT _vkReleaseSwapchainImagesEXT; + PFN_vkGetGeneratedCommandsMemoryRequirementsNV _vkGetGeneratedCommandsMemoryRequirementsNV; + PFN_vkCmdPreprocessGeneratedCommandsNV _vkCmdPreprocessGeneratedCommandsNV; + PFN_vkCmdExecuteGeneratedCommandsNV _vkCmdExecuteGeneratedCommandsNV; + PFN_vkCmdBindPipelineShaderGroupNV _vkCmdBindPipelineShaderGroupNV; + PFN_vkCreateIndirectCommandsLayoutNV _vkCreateIndirectCommandsLayoutNV; + PFN_vkDestroyIndirectCommandsLayoutNV _vkDestroyIndirectCommandsLayoutNV; + PFN_vkCmdSetDepthBias2EXT _vkCmdSetDepthBias2EXT; + PFN_vkCreatePrivateDataSlotEXT _vkCreatePrivateDataSlotEXT; + PFN_vkDestroyPrivateDataSlotEXT _vkDestroyPrivateDataSlotEXT; + PFN_vkSetPrivateDataEXT _vkSetPrivateDataEXT; + PFN_vkGetPrivateDataEXT _vkGetPrivateDataEXT; + PFN_vkCreateCudaModuleNV _vkCreateCudaModuleNV; + PFN_vkGetCudaModuleCacheNV _vkGetCudaModuleCacheNV; + PFN_vkCreateCudaFunctionNV _vkCreateCudaFunctionNV; + PFN_vkDestroyCudaModuleNV _vkDestroyCudaModuleNV; + PFN_vkDestroyCudaFunctionNV _vkDestroyCudaFunctionNV; + PFN_vkCmdCudaLaunchKernelNV _vkCmdCudaLaunchKernelNV; + PFN_vkGetDescriptorSetLayoutSizeEXT _vkGetDescriptorSetLayoutSizeEXT; + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT _vkGetDescriptorSetLayoutBindingOffsetEXT; + PFN_vkGetDescriptorEXT _vkGetDescriptorEXT; + PFN_vkCmdBindDescriptorBuffersEXT _vkCmdBindDescriptorBuffersEXT; + PFN_vkCmdSetDescriptorBufferOffsetsEXT _vkCmdSetDescriptorBufferOffsetsEXT; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT _vkCmdBindDescriptorBufferEmbeddedSamplersEXT; + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT _vkGetBufferOpaqueCaptureDescriptorDataEXT; + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT _vkGetImageOpaqueCaptureDescriptorDataEXT; + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT _vkGetImageViewOpaqueCaptureDescriptorDataEXT; + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT _vkGetSamplerOpaqueCaptureDescriptorDataEXT; + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT _vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; + PFN_vkCmdSetFragmentShadingRateEnumNV _vkCmdSetFragmentShadingRateEnumNV; + PFN_vkGetDeviceFaultInfoEXT _vkGetDeviceFaultInfoEXT; + PFN_vkCmdSetVertexInputEXT _vkCmdSetVertexInputEXT; + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI _vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; + PFN_vkCmdSubpassShadingHUAWEI _vkCmdSubpassShadingHUAWEI; + PFN_vkCmdBindInvocationMaskHUAWEI _vkCmdBindInvocationMaskHUAWEI; + PFN_vkGetMemoryRemoteAddressNV _vkGetMemoryRemoteAddressNV; + PFN_vkGetPipelinePropertiesEXT _vkGetPipelinePropertiesEXT; + PFN_vkCmdSetPatchControlPointsEXT _vkCmdSetPatchControlPointsEXT; + PFN_vkCmdSetRasterizerDiscardEnableEXT _vkCmdSetRasterizerDiscardEnableEXT; + PFN_vkCmdSetDepthBiasEnableEXT _vkCmdSetDepthBiasEnableEXT; + PFN_vkCmdSetLogicOpEXT _vkCmdSetLogicOpEXT; + PFN_vkCmdSetPrimitiveRestartEnableEXT _vkCmdSetPrimitiveRestartEnableEXT; + PFN_vkCmdSetColorWriteEnableEXT _vkCmdSetColorWriteEnableEXT; + PFN_vkCmdDrawMultiEXT _vkCmdDrawMultiEXT; + PFN_vkCmdDrawMultiIndexedEXT _vkCmdDrawMultiIndexedEXT; + PFN_vkCreateMicromapEXT _vkCreateMicromapEXT; + PFN_vkDestroyMicromapEXT _vkDestroyMicromapEXT; + PFN_vkCmdBuildMicromapsEXT _vkCmdBuildMicromapsEXT; + PFN_vkBuildMicromapsEXT _vkBuildMicromapsEXT; + PFN_vkCopyMicromapEXT _vkCopyMicromapEXT; + PFN_vkCopyMicromapToMemoryEXT _vkCopyMicromapToMemoryEXT; + PFN_vkCopyMemoryToMicromapEXT _vkCopyMemoryToMicromapEXT; + PFN_vkWriteMicromapsPropertiesEXT _vkWriteMicromapsPropertiesEXT; + PFN_vkCmdCopyMicromapEXT _vkCmdCopyMicromapEXT; + PFN_vkCmdCopyMicromapToMemoryEXT _vkCmdCopyMicromapToMemoryEXT; + PFN_vkCmdCopyMemoryToMicromapEXT _vkCmdCopyMemoryToMicromapEXT; + PFN_vkCmdWriteMicromapsPropertiesEXT _vkCmdWriteMicromapsPropertiesEXT; + PFN_vkGetDeviceMicromapCompatibilityEXT _vkGetDeviceMicromapCompatibilityEXT; + PFN_vkGetMicromapBuildSizesEXT _vkGetMicromapBuildSizesEXT; + PFN_vkCmdDrawClusterHUAWEI _vkCmdDrawClusterHUAWEI; + PFN_vkCmdDrawClusterIndirectHUAWEI _vkCmdDrawClusterIndirectHUAWEI; + PFN_vkSetDeviceMemoryPriorityEXT _vkSetDeviceMemoryPriorityEXT; + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE _vkGetDescriptorSetLayoutHostMappingInfoVALVE; + PFN_vkGetDescriptorSetHostMappingVALVE _vkGetDescriptorSetHostMappingVALVE; + PFN_vkCmdCopyMemoryIndirectNV _vkCmdCopyMemoryIndirectNV; + PFN_vkCmdCopyMemoryToImageIndirectNV _vkCmdCopyMemoryToImageIndirectNV; + PFN_vkCmdDecompressMemoryNV _vkCmdDecompressMemoryNV; + PFN_vkCmdDecompressMemoryIndirectCountNV _vkCmdDecompressMemoryIndirectCountNV; + PFN_vkGetPipelineIndirectMemoryRequirementsNV _vkGetPipelineIndirectMemoryRequirementsNV; + PFN_vkCmdUpdatePipelineIndirectBufferNV _vkCmdUpdatePipelineIndirectBufferNV; + PFN_vkGetPipelineIndirectDeviceAddressNV _vkGetPipelineIndirectDeviceAddressNV; + PFN_vkCmdSetDepthClampEnableEXT _vkCmdSetDepthClampEnableEXT; + PFN_vkCmdSetPolygonModeEXT _vkCmdSetPolygonModeEXT; + PFN_vkCmdSetRasterizationSamplesEXT _vkCmdSetRasterizationSamplesEXT; + PFN_vkCmdSetSampleMaskEXT _vkCmdSetSampleMaskEXT; + PFN_vkCmdSetAlphaToCoverageEnableEXT _vkCmdSetAlphaToCoverageEnableEXT; + PFN_vkCmdSetAlphaToOneEnableEXT _vkCmdSetAlphaToOneEnableEXT; + PFN_vkCmdSetLogicOpEnableEXT _vkCmdSetLogicOpEnableEXT; + PFN_vkCmdSetColorBlendEnableEXT _vkCmdSetColorBlendEnableEXT; + PFN_vkCmdSetColorBlendEquationEXT _vkCmdSetColorBlendEquationEXT; + PFN_vkCmdSetColorWriteMaskEXT _vkCmdSetColorWriteMaskEXT; + PFN_vkCmdSetTessellationDomainOriginEXT _vkCmdSetTessellationDomainOriginEXT; + PFN_vkCmdSetRasterizationStreamEXT _vkCmdSetRasterizationStreamEXT; + PFN_vkCmdSetConservativeRasterizationModeEXT _vkCmdSetConservativeRasterizationModeEXT; + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT _vkCmdSetExtraPrimitiveOverestimationSizeEXT; + PFN_vkCmdSetDepthClipEnableEXT _vkCmdSetDepthClipEnableEXT; + PFN_vkCmdSetSampleLocationsEnableEXT _vkCmdSetSampleLocationsEnableEXT; + PFN_vkCmdSetColorBlendAdvancedEXT _vkCmdSetColorBlendAdvancedEXT; + PFN_vkCmdSetProvokingVertexModeEXT _vkCmdSetProvokingVertexModeEXT; + PFN_vkCmdSetLineRasterizationModeEXT _vkCmdSetLineRasterizationModeEXT; + PFN_vkCmdSetLineStippleEnableEXT _vkCmdSetLineStippleEnableEXT; + PFN_vkCmdSetDepthClipNegativeOneToOneEXT _vkCmdSetDepthClipNegativeOneToOneEXT; + PFN_vkCmdSetViewportWScalingEnableNV _vkCmdSetViewportWScalingEnableNV; + PFN_vkCmdSetViewportSwizzleNV _vkCmdSetViewportSwizzleNV; + PFN_vkCmdSetCoverageToColorEnableNV _vkCmdSetCoverageToColorEnableNV; + PFN_vkCmdSetCoverageToColorLocationNV _vkCmdSetCoverageToColorLocationNV; + PFN_vkCmdSetCoverageModulationModeNV _vkCmdSetCoverageModulationModeNV; + PFN_vkCmdSetCoverageModulationTableEnableNV _vkCmdSetCoverageModulationTableEnableNV; + PFN_vkCmdSetCoverageModulationTableNV _vkCmdSetCoverageModulationTableNV; + PFN_vkCmdSetShadingRateImageEnableNV _vkCmdSetShadingRateImageEnableNV; + PFN_vkCmdSetRepresentativeFragmentTestEnableNV _vkCmdSetRepresentativeFragmentTestEnableNV; + PFN_vkCmdSetCoverageReductionModeNV _vkCmdSetCoverageReductionModeNV; + PFN_vkGetShaderModuleIdentifierEXT _vkGetShaderModuleIdentifierEXT; + PFN_vkGetShaderModuleCreateInfoIdentifierEXT _vkGetShaderModuleCreateInfoIdentifierEXT; + PFN_vkCreateOpticalFlowSessionNV _vkCreateOpticalFlowSessionNV; + PFN_vkDestroyOpticalFlowSessionNV _vkDestroyOpticalFlowSessionNV; + PFN_vkBindOpticalFlowSessionImageNV _vkBindOpticalFlowSessionImageNV; + PFN_vkCmdOpticalFlowExecuteNV _vkCmdOpticalFlowExecuteNV; + PFN_vkCreateShadersEXT _vkCreateShadersEXT; + PFN_vkDestroyShaderEXT _vkDestroyShaderEXT; + PFN_vkGetShaderBinaryDataEXT _vkGetShaderBinaryDataEXT; + PFN_vkCmdBindShadersEXT _vkCmdBindShadersEXT; + PFN_vkGetFramebufferTilePropertiesQCOM _vkGetFramebufferTilePropertiesQCOM; + PFN_vkGetDynamicRenderingTilePropertiesQCOM _vkGetDynamicRenderingTilePropertiesQCOM; + PFN_vkSetLatencySleepModeNV _vkSetLatencySleepModeNV; + PFN_vkLatencySleepNV _vkLatencySleepNV; + PFN_vkSetLatencyMarkerNV _vkSetLatencyMarkerNV; + PFN_vkGetLatencyTimingsNV _vkGetLatencyTimingsNV; + PFN_vkQueueNotifyOutOfBandNV _vkQueueNotifyOutOfBandNV; + PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT _vkCmdSetAttachmentFeedbackLoopEnableEXT; + PFN_vkCreateAccelerationStructureKHR _vkCreateAccelerationStructureKHR; + PFN_vkDestroyAccelerationStructureKHR _vkDestroyAccelerationStructureKHR; + PFN_vkCmdBuildAccelerationStructuresKHR _vkCmdBuildAccelerationStructuresKHR; + PFN_vkCmdBuildAccelerationStructuresIndirectKHR _vkCmdBuildAccelerationStructuresIndirectKHR; + PFN_vkBuildAccelerationStructuresKHR _vkBuildAccelerationStructuresKHR; + PFN_vkCopyAccelerationStructureKHR _vkCopyAccelerationStructureKHR; + PFN_vkCopyAccelerationStructureToMemoryKHR _vkCopyAccelerationStructureToMemoryKHR; + PFN_vkCopyMemoryToAccelerationStructureKHR _vkCopyMemoryToAccelerationStructureKHR; + PFN_vkWriteAccelerationStructuresPropertiesKHR _vkWriteAccelerationStructuresPropertiesKHR; + PFN_vkCmdCopyAccelerationStructureKHR _vkCmdCopyAccelerationStructureKHR; + PFN_vkCmdCopyAccelerationStructureToMemoryKHR _vkCmdCopyAccelerationStructureToMemoryKHR; + PFN_vkCmdCopyMemoryToAccelerationStructureKHR _vkCmdCopyMemoryToAccelerationStructureKHR; + PFN_vkGetAccelerationStructureDeviceAddressKHR _vkGetAccelerationStructureDeviceAddressKHR; + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR _vkCmdWriteAccelerationStructuresPropertiesKHR; + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR _vkGetDeviceAccelerationStructureCompatibilityKHR; + PFN_vkGetAccelerationStructureBuildSizesKHR _vkGetAccelerationStructureBuildSizesKHR; + PFN_vkCmdTraceRaysKHR _vkCmdTraceRaysKHR; + PFN_vkCreateRayTracingPipelinesKHR _vkCreateRayTracingPipelinesKHR; + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR _vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; + PFN_vkCmdTraceRaysIndirectKHR _vkCmdTraceRaysIndirectKHR; + PFN_vkGetRayTracingShaderGroupStackSizeKHR _vkGetRayTracingShaderGroupStackSizeKHR; + PFN_vkCmdSetRayTracingPipelineStackSizeKHR _vkCmdSetRayTracingPipelineStackSizeKHR; + PFN_vkCmdDrawMeshTasksEXT _vkCmdDrawMeshTasksEXT; + PFN_vkCmdDrawMeshTasksIndirectEXT _vkCmdDrawMeshTasksIndirectEXT; + PFN_vkCmdDrawMeshTasksIndirectCountEXT _vkCmdDrawMeshTasksIndirectCountEXT; + + VkDevice _device = {}; +}; diff --git a/Src/RenderFramework/Vulkan/VulkanDynamicLibrary.h b/Src/RenderFramework/Vulkan/VulkanDynamicLibrary.h new file mode 100644 index 0000000..2ba7f1c --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanDynamicLibrary.h @@ -0,0 +1,21 @@ +#pragma once + +#include "VulkanLibrary.h" +#include "DynamicLibrary.h" +#include +#include +#include + +class VulkanDynamicLibrary : public VulkanLibrary { +public: + VulkanDynamicLibrary(const std::filesystem::path& path = "vulkan-1") : _library(path) { + getInstanceProcAddr = _library.getFunction("vkGetInstanceProcAddr"); + + #define VK_USE_GLOBAL_FUNCTION(name) _functions.name = reinterpret_cast(getInstanceProcAddr(nullptr, #name)); + VK_GLOBAL_FUNCTIONS + #undef VK_USE_GLOBAL_FUNCTION + } + +private: + DynamicLibrary _library; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanFrameBuffer.cpp b/Src/RenderFramework/Vulkan/VulkanFrameBuffer.cpp new file mode 100644 index 0000000..938196e --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanFrameBuffer.cpp @@ -0,0 +1,16 @@ +#include "VulkanFrameBuffer.h" +#include "VulkanLogicalDevice.h" + +VulkanFrameBuffer::VulkanFrameBuffer(IntrusivePtr device, const VkFramebufferCreateInfo& createInfo) : _device(device){ + if (_device->functions().vkCreateFramebuffer(&createInfo, nullptr, &_native) != VK_SUCCESS) { + throw std::runtime_error("failed to create framebuffer!"); + } +} +VulkanFrameBuffer::VulkanFrameBuffer(IntrusivePtr device, VkFramebuffer native) : _device(device), _native(native){ + +} +VulkanFrameBuffer::~VulkanFrameBuffer(){ + if(_native != nullptr){ + _device->functions().vkDestroyFramebuffer(_native, nullptr); + } +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanFrameBuffer.h b/Src/RenderFramework/Vulkan/VulkanFrameBuffer.h new file mode 100644 index 0000000..1f462a0 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanFrameBuffer.h @@ -0,0 +1,20 @@ +#pragma once + +#include "IntrusivePtr.h" +#include "RefCountedObject.h" +#include + +class VulkanLogicalDevice; + +class VulkanFrameBuffer : public RefCountedObject { +public: + VulkanFrameBuffer(IntrusivePtr device, const VkFramebufferCreateInfo& createInfo); + VulkanFrameBuffer(IntrusivePtr device, VkFramebuffer native); + VkFramebuffer native() const { + return _native; + } + ~VulkanFrameBuffer(); +private: + IntrusivePtr _device; + VkFramebuffer _native; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanFunctions.h b/Src/RenderFramework/Vulkan/VulkanFunctions.h new file mode 100644 index 0000000..d9cbd70 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanFunctions.h @@ -0,0 +1,636 @@ +#define VK_INSTANCE_FUNCTIONS \ + VK_USE_INSTANCE_FUNCTION(vkDestroyInstance) \ + VK_USE_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceFormatProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceImageFormatProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetInstanceProcAddr) \ + VK_USE_INSTANCE_FUNCTION(vkGetDeviceProcAddr) \ + VK_USE_INSTANCE_FUNCTION(vkCreateDevice) \ + VK_USE_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties) \ + VK_USE_INSTANCE_FUNCTION(vkEnumerateDeviceLayerProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSparseImageFormatProperties) \ + VK_USE_INSTANCE_FUNCTION(vkEnumeratePhysicalDeviceGroups) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures2) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties2) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceFormatProperties2) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceImageFormatProperties2) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties2) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties2) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSparseImageFormatProperties2) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceExternalBufferProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceExternalFenceProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceExternalSemaphoreProperties) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceToolProperties) \ + VK_USE_INSTANCE_FUNCTION(vkDestroySurfaceKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDevicePresentRectanglesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceDisplayPropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceDisplayPlanePropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetDisplayPlaneSupportedDisplaysKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetDisplayModePropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkCreateDisplayModeKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetDisplayPlaneCapabilitiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkCreateDisplayPlaneSurfaceKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceVideoCapabilitiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceVideoFormatPropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceFormatProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceImageFormatProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSparseImageFormatProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkEnumeratePhysicalDeviceGroupsKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceExternalBufferPropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceExternalFencePropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilities2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormats2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceDisplayProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceDisplayPlaneProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetDisplayModeProperties2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetDisplayPlaneCapabilities2KHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceFragmentShadingRatesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR) \ + VK_USE_INSTANCE_FUNCTION(vkCreateDebugReportCallbackEXT) \ + VK_USE_INSTANCE_FUNCTION(vkDestroyDebugReportCallbackEXT) \ + VK_USE_INSTANCE_FUNCTION(vkDebugReportMessageEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceExternalImageFormatPropertiesNV) \ + VK_USE_INSTANCE_FUNCTION(vkReleaseDisplayEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilities2EXT) \ + VK_USE_INSTANCE_FUNCTION(vkCreateDebugUtilsMessengerEXT) \ + VK_USE_INSTANCE_FUNCTION(vkDestroyDebugUtilsMessengerEXT) \ + VK_USE_INSTANCE_FUNCTION(vkSubmitDebugUtilsMessageEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceMultisamplePropertiesEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceToolPropertiesEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV) \ + VK_USE_INSTANCE_FUNCTION(vkCreateHeadlessSurfaceEXT) \ + VK_USE_INSTANCE_FUNCTION(vkAcquireDrmDisplayEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetDrmDisplayEXT) \ + VK_USE_INSTANCE_FUNCTION(vkGetPhysicalDeviceOpticalFlowImageFormatsNV) \ + +#define VK_DEVICE_FUNCTIONS \ + VK_USE_DEVICE_FUNCTION(vkDestroyDevice) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceQueue) \ + VK_USE_DEVICE_FUNCTION(vkDeviceWaitIdle) \ + VK_USE_DEVICE_FUNCTION(vkAllocateMemory) \ + VK_USE_DEVICE_FUNCTION(vkFreeMemory) \ + VK_USE_DEVICE_FUNCTION(vkMapMemory) \ + VK_USE_DEVICE_FUNCTION(vkUnmapMemory) \ + VK_USE_DEVICE_FUNCTION(vkFlushMappedMemoryRanges) \ + VK_USE_DEVICE_FUNCTION(vkInvalidateMappedMemoryRanges) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceMemoryCommitment) \ + VK_USE_DEVICE_FUNCTION(vkBindBufferMemory) \ + VK_USE_DEVICE_FUNCTION(vkBindImageMemory) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferMemoryRequirements) \ + VK_USE_DEVICE_FUNCTION(vkGetImageMemoryRequirements) \ + VK_USE_DEVICE_FUNCTION(vkGetImageSparseMemoryRequirements) \ + VK_USE_DEVICE_FUNCTION(vkCreateFence) \ + VK_USE_DEVICE_FUNCTION(vkDestroyFence) \ + VK_USE_DEVICE_FUNCTION(vkResetFences) \ + VK_USE_DEVICE_FUNCTION(vkGetFenceStatus) \ + VK_USE_DEVICE_FUNCTION(vkWaitForFences) \ + VK_USE_DEVICE_FUNCTION(vkCreateSemaphore) \ + VK_USE_DEVICE_FUNCTION(vkDestroySemaphore) \ + VK_USE_DEVICE_FUNCTION(vkCreateEvent) \ + VK_USE_DEVICE_FUNCTION(vkDestroyEvent) \ + VK_USE_DEVICE_FUNCTION(vkGetEventStatus) \ + VK_USE_DEVICE_FUNCTION(vkSetEvent) \ + VK_USE_DEVICE_FUNCTION(vkResetEvent) \ + VK_USE_DEVICE_FUNCTION(vkCreateQueryPool) \ + VK_USE_DEVICE_FUNCTION(vkDestroyQueryPool) \ + VK_USE_DEVICE_FUNCTION(vkGetQueryPoolResults) \ + VK_USE_DEVICE_FUNCTION(vkCreateBuffer) \ + VK_USE_DEVICE_FUNCTION(vkDestroyBuffer) \ + VK_USE_DEVICE_FUNCTION(vkCreateBufferView) \ + VK_USE_DEVICE_FUNCTION(vkDestroyBufferView) \ + VK_USE_DEVICE_FUNCTION(vkCreateImage) \ + VK_USE_DEVICE_FUNCTION(vkDestroyImage) \ + VK_USE_DEVICE_FUNCTION(vkGetImageSubresourceLayout) \ + VK_USE_DEVICE_FUNCTION(vkCreateImageView) \ + VK_USE_DEVICE_FUNCTION(vkDestroyImageView) \ + VK_USE_DEVICE_FUNCTION(vkCreateShaderModule) \ + VK_USE_DEVICE_FUNCTION(vkDestroyShaderModule) \ + VK_USE_DEVICE_FUNCTION(vkCreatePipelineCache) \ + VK_USE_DEVICE_FUNCTION(vkDestroyPipelineCache) \ + VK_USE_DEVICE_FUNCTION(vkGetPipelineCacheData) \ + VK_USE_DEVICE_FUNCTION(vkMergePipelineCaches) \ + VK_USE_DEVICE_FUNCTION(vkCreateGraphicsPipelines) \ + VK_USE_DEVICE_FUNCTION(vkCreateComputePipelines) \ + VK_USE_DEVICE_FUNCTION(vkDestroyPipeline) \ + VK_USE_DEVICE_FUNCTION(vkCreatePipelineLayout) \ + VK_USE_DEVICE_FUNCTION(vkDestroyPipelineLayout) \ + VK_USE_DEVICE_FUNCTION(vkCreateSampler) \ + VK_USE_DEVICE_FUNCTION(vkDestroySampler) \ + VK_USE_DEVICE_FUNCTION(vkCreateDescriptorSetLayout) \ + VK_USE_DEVICE_FUNCTION(vkDestroyDescriptorSetLayout) \ + VK_USE_DEVICE_FUNCTION(vkCreateDescriptorPool) \ + VK_USE_DEVICE_FUNCTION(vkDestroyDescriptorPool) \ + VK_USE_DEVICE_FUNCTION(vkResetDescriptorPool) \ + VK_USE_DEVICE_FUNCTION(vkAllocateDescriptorSets) \ + VK_USE_DEVICE_FUNCTION(vkFreeDescriptorSets) \ + VK_USE_DEVICE_FUNCTION(vkUpdateDescriptorSets) \ + VK_USE_DEVICE_FUNCTION(vkCreateFramebuffer) \ + VK_USE_DEVICE_FUNCTION(vkDestroyFramebuffer) \ + VK_USE_DEVICE_FUNCTION(vkCreateRenderPass) \ + VK_USE_DEVICE_FUNCTION(vkDestroyRenderPass) \ + VK_USE_DEVICE_FUNCTION(vkGetRenderAreaGranularity) \ + VK_USE_DEVICE_FUNCTION(vkCreateCommandPool) \ + VK_USE_DEVICE_FUNCTION(vkDestroyCommandPool) \ + VK_USE_DEVICE_FUNCTION(vkResetCommandPool) \ + VK_USE_DEVICE_FUNCTION(vkAllocateCommandBuffers) \ + VK_USE_DEVICE_FUNCTION(vkFreeCommandBuffers) \ + VK_USE_DEVICE_FUNCTION(vkBindBufferMemory2) \ + VK_USE_DEVICE_FUNCTION(vkBindImageMemory2) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceGroupPeerMemoryFeatures) \ + VK_USE_DEVICE_FUNCTION(vkGetImageMemoryRequirements2) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferMemoryRequirements2) \ + VK_USE_DEVICE_FUNCTION(vkGetImageSparseMemoryRequirements2) \ + VK_USE_DEVICE_FUNCTION(vkTrimCommandPool) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceQueue2) \ + VK_USE_DEVICE_FUNCTION(vkCreateSamplerYcbcrConversion) \ + VK_USE_DEVICE_FUNCTION(vkDestroySamplerYcbcrConversion) \ + VK_USE_DEVICE_FUNCTION(vkCreateDescriptorUpdateTemplate) \ + VK_USE_DEVICE_FUNCTION(vkDestroyDescriptorUpdateTemplate) \ + VK_USE_DEVICE_FUNCTION(vkUpdateDescriptorSetWithTemplate) \ + VK_USE_DEVICE_FUNCTION(vkGetDescriptorSetLayoutSupport) \ + VK_USE_DEVICE_FUNCTION(vkCreateRenderPass2) \ + VK_USE_DEVICE_FUNCTION(vkResetQueryPool) \ + VK_USE_DEVICE_FUNCTION(vkGetSemaphoreCounterValue) \ + VK_USE_DEVICE_FUNCTION(vkWaitSemaphores) \ + VK_USE_DEVICE_FUNCTION(vkSignalSemaphore) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferDeviceAddress) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferOpaqueCaptureAddress) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceMemoryOpaqueCaptureAddress) \ + VK_USE_DEVICE_FUNCTION(vkCreatePrivateDataSlot) \ + VK_USE_DEVICE_FUNCTION(vkDestroyPrivateDataSlot) \ + VK_USE_DEVICE_FUNCTION(vkSetPrivateData) \ + VK_USE_DEVICE_FUNCTION(vkGetPrivateData) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceBufferMemoryRequirements) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceImageMemoryRequirements) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceImageSparseMemoryRequirements) \ + VK_USE_DEVICE_FUNCTION(vkCreateSwapchainKHR) \ + VK_USE_DEVICE_FUNCTION(vkDestroySwapchainKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetSwapchainImagesKHR) \ + VK_USE_DEVICE_FUNCTION(vkAcquireNextImageKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceGroupPresentCapabilitiesKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceGroupSurfacePresentModesKHR) \ + VK_USE_DEVICE_FUNCTION(vkAcquireNextImage2KHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateSharedSwapchainsKHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateVideoSessionKHR) \ + VK_USE_DEVICE_FUNCTION(vkDestroyVideoSessionKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetVideoSessionMemoryRequirementsKHR) \ + VK_USE_DEVICE_FUNCTION(vkBindVideoSessionMemoryKHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateVideoSessionParametersKHR) \ + VK_USE_DEVICE_FUNCTION(vkUpdateVideoSessionParametersKHR) \ + VK_USE_DEVICE_FUNCTION(vkDestroyVideoSessionParametersKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceGroupPeerMemoryFeaturesKHR) \ + VK_USE_DEVICE_FUNCTION(vkTrimCommandPoolKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetMemoryFdKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetMemoryFdPropertiesKHR) \ + VK_USE_DEVICE_FUNCTION(vkImportSemaphoreFdKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetSemaphoreFdKHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateDescriptorUpdateTemplateKHR) \ + VK_USE_DEVICE_FUNCTION(vkDestroyDescriptorUpdateTemplateKHR) \ + VK_USE_DEVICE_FUNCTION(vkUpdateDescriptorSetWithTemplateKHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateRenderPass2KHR) \ + VK_USE_DEVICE_FUNCTION(vkGetSwapchainStatusKHR) \ + VK_USE_DEVICE_FUNCTION(vkImportFenceFdKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetFenceFdKHR) \ + VK_USE_DEVICE_FUNCTION(vkAcquireProfilingLockKHR) \ + VK_USE_DEVICE_FUNCTION(vkReleaseProfilingLockKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetImageMemoryRequirements2KHR) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferMemoryRequirements2KHR) \ + VK_USE_DEVICE_FUNCTION(vkGetImageSparseMemoryRequirements2KHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateSamplerYcbcrConversionKHR) \ + VK_USE_DEVICE_FUNCTION(vkDestroySamplerYcbcrConversionKHR) \ + VK_USE_DEVICE_FUNCTION(vkBindBufferMemory2KHR) \ + VK_USE_DEVICE_FUNCTION(vkBindImageMemory2KHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDescriptorSetLayoutSupportKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetSemaphoreCounterValueKHR) \ + VK_USE_DEVICE_FUNCTION(vkWaitSemaphoresKHR) \ + VK_USE_DEVICE_FUNCTION(vkSignalSemaphoreKHR) \ + VK_USE_DEVICE_FUNCTION(vkWaitForPresentKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferDeviceAddressKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferOpaqueCaptureAddressKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceMemoryOpaqueCaptureAddressKHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateDeferredOperationKHR) \ + VK_USE_DEVICE_FUNCTION(vkDestroyDeferredOperationKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeferredOperationMaxConcurrencyKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeferredOperationResultKHR) \ + VK_USE_DEVICE_FUNCTION(vkDeferredOperationJoinKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetPipelineExecutablePropertiesKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetPipelineExecutableStatisticsKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetPipelineExecutableInternalRepresentationsKHR) \ + VK_USE_DEVICE_FUNCTION(vkMapMemory2KHR) \ + VK_USE_DEVICE_FUNCTION(vkUnmapMemory2KHR) \ + VK_USE_DEVICE_FUNCTION(vkGetEncodedVideoSessionParametersKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceBufferMemoryRequirementsKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceImageMemoryRequirementsKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceImageSparseMemoryRequirementsKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetRenderingAreaGranularityKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceImageSubresourceLayoutKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetImageSubresourceLayout2KHR) \ + VK_USE_DEVICE_FUNCTION(vkGetCalibratedTimestampsKHR) \ + VK_USE_DEVICE_FUNCTION(vkDebugMarkerSetObjectTagEXT) \ + VK_USE_DEVICE_FUNCTION(vkDebugMarkerSetObjectNameEXT) \ + VK_USE_DEVICE_FUNCTION(vkCreateCuModuleNVX) \ + VK_USE_DEVICE_FUNCTION(vkCreateCuFunctionNVX) \ + VK_USE_DEVICE_FUNCTION(vkDestroyCuModuleNVX) \ + VK_USE_DEVICE_FUNCTION(vkDestroyCuFunctionNVX) \ + VK_USE_DEVICE_FUNCTION(vkGetImageViewHandleNVX) \ + VK_USE_DEVICE_FUNCTION(vkGetImageViewAddressNVX) \ + VK_USE_DEVICE_FUNCTION(vkGetShaderInfoAMD) \ + VK_USE_DEVICE_FUNCTION(vkDisplayPowerControlEXT) \ + VK_USE_DEVICE_FUNCTION(vkRegisterDeviceEventEXT) \ + VK_USE_DEVICE_FUNCTION(vkRegisterDisplayEventEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetSwapchainCounterEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetRefreshCycleDurationGOOGLE) \ + VK_USE_DEVICE_FUNCTION(vkGetPastPresentationTimingGOOGLE) \ + VK_USE_DEVICE_FUNCTION(vkSetHdrMetadataEXT) \ + VK_USE_DEVICE_FUNCTION(vkSetDebugUtilsObjectNameEXT) \ + VK_USE_DEVICE_FUNCTION(vkSetDebugUtilsObjectTagEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetImageDrmFormatModifierPropertiesEXT) \ + VK_USE_DEVICE_FUNCTION(vkCreateValidationCacheEXT) \ + VK_USE_DEVICE_FUNCTION(vkDestroyValidationCacheEXT) \ + VK_USE_DEVICE_FUNCTION(vkMergeValidationCachesEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetValidationCacheDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkCreateAccelerationStructureNV) \ + VK_USE_DEVICE_FUNCTION(vkDestroyAccelerationStructureNV) \ + VK_USE_DEVICE_FUNCTION(vkGetAccelerationStructureMemoryRequirementsNV) \ + VK_USE_DEVICE_FUNCTION(vkBindAccelerationStructureMemoryNV) \ + VK_USE_DEVICE_FUNCTION(vkCreateRayTracingPipelinesNV) \ + VK_USE_DEVICE_FUNCTION(vkGetRayTracingShaderGroupHandlesKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetRayTracingShaderGroupHandlesNV) \ + VK_USE_DEVICE_FUNCTION(vkGetAccelerationStructureHandleNV) \ + VK_USE_DEVICE_FUNCTION(vkCompileDeferredNV) \ + VK_USE_DEVICE_FUNCTION(vkGetMemoryHostPointerPropertiesEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetCalibratedTimestampsEXT) \ + VK_USE_DEVICE_FUNCTION(vkInitializePerformanceApiINTEL) \ + VK_USE_DEVICE_FUNCTION(vkUninitializePerformanceApiINTEL) \ + VK_USE_DEVICE_FUNCTION(vkAcquirePerformanceConfigurationINTEL) \ + VK_USE_DEVICE_FUNCTION(vkReleasePerformanceConfigurationINTEL) \ + VK_USE_DEVICE_FUNCTION(vkGetPerformanceParameterINTEL) \ + VK_USE_DEVICE_FUNCTION(vkSetLocalDimmingAMD) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferDeviceAddressEXT) \ + VK_USE_DEVICE_FUNCTION(vkResetQueryPoolEXT) \ + VK_USE_DEVICE_FUNCTION(vkCopyMemoryToImageEXT) \ + VK_USE_DEVICE_FUNCTION(vkCopyImageToMemoryEXT) \ + VK_USE_DEVICE_FUNCTION(vkCopyImageToImageEXT) \ + VK_USE_DEVICE_FUNCTION(vkTransitionImageLayoutEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetImageSubresourceLayout2EXT) \ + VK_USE_DEVICE_FUNCTION(vkReleaseSwapchainImagesEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetGeneratedCommandsMemoryRequirementsNV) \ + VK_USE_DEVICE_FUNCTION(vkCreateIndirectCommandsLayoutNV) \ + VK_USE_DEVICE_FUNCTION(vkDestroyIndirectCommandsLayoutNV) \ + VK_USE_DEVICE_FUNCTION(vkCreatePrivateDataSlotEXT) \ + VK_USE_DEVICE_FUNCTION(vkDestroyPrivateDataSlotEXT) \ + VK_USE_DEVICE_FUNCTION(vkSetPrivateDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetPrivateDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkCreateCudaModuleNV) \ + VK_USE_DEVICE_FUNCTION(vkGetCudaModuleCacheNV) \ + VK_USE_DEVICE_FUNCTION(vkCreateCudaFunctionNV) \ + VK_USE_DEVICE_FUNCTION(vkDestroyCudaModuleNV) \ + VK_USE_DEVICE_FUNCTION(vkDestroyCudaFunctionNV) \ + VK_USE_DEVICE_FUNCTION(vkGetDescriptorSetLayoutSizeEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetDescriptorSetLayoutBindingOffsetEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetDescriptorEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetBufferOpaqueCaptureDescriptorDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetImageOpaqueCaptureDescriptorDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetImageViewOpaqueCaptureDescriptorDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetSamplerOpaqueCaptureDescriptorDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceFaultInfoEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI) \ + VK_USE_DEVICE_FUNCTION(vkGetMemoryRemoteAddressNV) \ + VK_USE_DEVICE_FUNCTION(vkGetPipelinePropertiesEXT) \ + VK_USE_DEVICE_FUNCTION(vkCreateMicromapEXT) \ + VK_USE_DEVICE_FUNCTION(vkDestroyMicromapEXT) \ + VK_USE_DEVICE_FUNCTION(vkBuildMicromapsEXT) \ + VK_USE_DEVICE_FUNCTION(vkCopyMicromapEXT) \ + VK_USE_DEVICE_FUNCTION(vkCopyMicromapToMemoryEXT) \ + VK_USE_DEVICE_FUNCTION(vkCopyMemoryToMicromapEXT) \ + VK_USE_DEVICE_FUNCTION(vkWriteMicromapsPropertiesEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceMicromapCompatibilityEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetMicromapBuildSizesEXT) \ + VK_USE_DEVICE_FUNCTION(vkSetDeviceMemoryPriorityEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetDescriptorSetLayoutHostMappingInfoVALVE) \ + VK_USE_DEVICE_FUNCTION(vkGetDescriptorSetHostMappingVALVE) \ + VK_USE_DEVICE_FUNCTION(vkGetPipelineIndirectMemoryRequirementsNV) \ + VK_USE_DEVICE_FUNCTION(vkGetPipelineIndirectDeviceAddressNV) \ + VK_USE_DEVICE_FUNCTION(vkGetShaderModuleIdentifierEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetShaderModuleCreateInfoIdentifierEXT) \ + VK_USE_DEVICE_FUNCTION(vkCreateOpticalFlowSessionNV) \ + VK_USE_DEVICE_FUNCTION(vkDestroyOpticalFlowSessionNV) \ + VK_USE_DEVICE_FUNCTION(vkBindOpticalFlowSessionImageNV) \ + VK_USE_DEVICE_FUNCTION(vkCreateShadersEXT) \ + VK_USE_DEVICE_FUNCTION(vkDestroyShaderEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetShaderBinaryDataEXT) \ + VK_USE_DEVICE_FUNCTION(vkGetFramebufferTilePropertiesQCOM) \ + VK_USE_DEVICE_FUNCTION(vkGetDynamicRenderingTilePropertiesQCOM) \ + VK_USE_DEVICE_FUNCTION(vkSetLatencySleepModeNV) \ + VK_USE_DEVICE_FUNCTION(vkLatencySleepNV) \ + VK_USE_DEVICE_FUNCTION(vkSetLatencyMarkerNV) \ + VK_USE_DEVICE_FUNCTION(vkGetLatencyTimingsNV) \ + VK_USE_DEVICE_FUNCTION(vkCreateAccelerationStructureKHR) \ + VK_USE_DEVICE_FUNCTION(vkDestroyAccelerationStructureKHR) \ + VK_USE_DEVICE_FUNCTION(vkBuildAccelerationStructuresKHR) \ + VK_USE_DEVICE_FUNCTION(vkCopyAccelerationStructureKHR) \ + VK_USE_DEVICE_FUNCTION(vkCopyAccelerationStructureToMemoryKHR) \ + VK_USE_DEVICE_FUNCTION(vkCopyMemoryToAccelerationStructureKHR) \ + VK_USE_DEVICE_FUNCTION(vkWriteAccelerationStructuresPropertiesKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetAccelerationStructureDeviceAddressKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetDeviceAccelerationStructureCompatibilityKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetAccelerationStructureBuildSizesKHR) \ + VK_USE_DEVICE_FUNCTION(vkCreateRayTracingPipelinesKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR) \ + VK_USE_DEVICE_FUNCTION(vkGetRayTracingShaderGroupStackSizeKHR) \ + +#define VK_DEVICE_QUEUE_FUNCTIONS \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueSubmit) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueWaitIdle) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueBindSparse) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueSubmit2) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueuePresentKHR) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueSubmit2KHR) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkGetQueueCheckpointData2NV) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueBeginDebugUtilsLabelEXT) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueEndDebugUtilsLabelEXT) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueInsertDebugUtilsLabelEXT) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkGetQueueCheckpointDataNV) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueSetPerformanceConfigurationINTEL) \ + VK_USE_DEVICE_QUEUE_FUNCTION(vkQueueNotifyOutOfBandNV) \ + +#define VK_DEVICE_CMD_FUNCTIONS \ + VK_USE_DEVICE_CMD_FUNCTION(vkBeginCommandBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkEndCommandBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkResetCommandBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindPipeline) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetViewport) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetScissor) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetLineWidth) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthBias) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetBlendConstants) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthBounds) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetStencilCompareMask) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetStencilWriteMask) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetStencilReference) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindDescriptorSets) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindIndexBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindVertexBuffers) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDraw) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndexed) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndirect) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndexedIndirect) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDispatch) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDispatchIndirect) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyImage) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBlitImage) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyBufferToImage) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyImageToBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdUpdateBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdFillBuffer) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdClearColorImage) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdClearDepthStencilImage) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdClearAttachments) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdResolveImage) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetEvent) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdResetEvent) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWaitEvents) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPipelineBarrier) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginQuery) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndQuery) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdResetQueryPool) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteTimestamp) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyQueryPoolResults) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPushConstants) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginRenderPass) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdNextSubpass) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndRenderPass) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdExecuteCommands) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDeviceMask) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDispatchBase) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndirectCount) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndexedIndirectCount) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginRenderPass2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdNextSubpass2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndRenderPass2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetEvent2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdResetEvent2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWaitEvents2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPipelineBarrier2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteTimestamp2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyBuffer2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyImage2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyBufferToImage2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyImageToBuffer2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBlitImage2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdResolveImage2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginRendering) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndRendering) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCullMode) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetFrontFace) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPrimitiveTopology) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetViewportWithCount) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetScissorWithCount) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindVertexBuffers2) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthTestEnable) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthWriteEnable) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthCompareOp) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthBoundsTestEnable) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetStencilTestEnable) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetStencilOp) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRasterizerDiscardEnable) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthBiasEnable) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPrimitiveRestartEnable) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginVideoCodingKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndVideoCodingKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdControlVideoCodingKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDecodeVideoKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginRenderingKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndRenderingKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDeviceMaskKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDispatchBaseKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPushDescriptorSetKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPushDescriptorSetWithTemplateKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginRenderPass2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdNextSubpass2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndRenderPass2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndirectCountKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndexedIndirectCountKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetFragmentShadingRateKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRenderingAttachmentLocationsKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRenderingInputAttachmentIndicesKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEncodeVideoKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetEvent2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdResetEvent2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWaitEvents2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPipelineBarrier2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteTimestamp2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteBufferMarker2AMD) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyBuffer2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyImage2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyBufferToImage2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyImageToBuffer2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBlitImage2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdResolveImage2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdTraceRaysIndirect2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindIndexBuffer2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetLineStippleKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindDescriptorSets2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPushConstants2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPushDescriptorSet2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPushDescriptorSetWithTemplate2KHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDescriptorBufferOffsets2EXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDebugMarkerBeginEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDebugMarkerEndEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDebugMarkerInsertEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindTransformFeedbackBuffersEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginTransformFeedbackEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndTransformFeedbackEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginQueryIndexedEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndQueryIndexedEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndirectByteCountEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCuLaunchKernelNVX) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndirectCountAMD) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawIndexedIndirectCountAMD) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginConditionalRenderingEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndConditionalRenderingEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetViewportWScalingNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDiscardRectangleEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDiscardRectangleEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDiscardRectangleModeEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBeginDebugUtilsLabelEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdEndDebugUtilsLabelEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdInsertDebugUtilsLabelEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetSampleLocationsEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindShadingRateImageNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetViewportShadingRatePaletteNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCoarseSampleOrderNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBuildAccelerationStructureNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyAccelerationStructureNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdTraceRaysNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteAccelerationStructuresPropertiesNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteBufferMarkerAMD) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMeshTasksNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMeshTasksIndirectNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMeshTasksIndirectCountNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetExclusiveScissorEnableNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetExclusiveScissorNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCheckpointNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPerformanceMarkerINTEL) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPerformanceStreamMarkerINTEL) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPerformanceOverrideINTEL) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetLineStippleEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCullModeEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetFrontFaceEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPrimitiveTopologyEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetViewportWithCountEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetScissorWithCountEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindVertexBuffers2EXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthTestEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthWriteEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthCompareOpEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthBoundsTestEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetStencilTestEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetStencilOpEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdPreprocessGeneratedCommandsNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdExecuteGeneratedCommandsNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindPipelineShaderGroupNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthBias2EXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCudaLaunchKernelNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindDescriptorBuffersEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDescriptorBufferOffsetsEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindDescriptorBufferEmbeddedSamplersEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetFragmentShadingRateEnumNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetVertexInputEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSubpassShadingHUAWEI) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindInvocationMaskHUAWEI) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPatchControlPointsEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRasterizerDiscardEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthBiasEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetLogicOpEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPrimitiveRestartEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetColorWriteEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMultiEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMultiIndexedEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBuildMicromapsEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyMicromapEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyMicromapToMemoryEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyMemoryToMicromapEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteMicromapsPropertiesEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawClusterHUAWEI) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawClusterIndirectHUAWEI) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyMemoryIndirectNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyMemoryToImageIndirectNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDecompressMemoryNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDecompressMemoryIndirectCountNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdUpdatePipelineIndirectBufferNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthClampEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetPolygonModeEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRasterizationSamplesEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetSampleMaskEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetAlphaToCoverageEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetAlphaToOneEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetLogicOpEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetColorBlendEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetColorBlendEquationEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetColorWriteMaskEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetTessellationDomainOriginEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRasterizationStreamEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetConservativeRasterizationModeEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetExtraPrimitiveOverestimationSizeEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthClipEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetSampleLocationsEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetColorBlendAdvancedEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetProvokingVertexModeEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetLineRasterizationModeEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetLineStippleEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetDepthClipNegativeOneToOneEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetViewportWScalingEnableNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetViewportSwizzleNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCoverageToColorEnableNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCoverageToColorLocationNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCoverageModulationModeNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCoverageModulationTableEnableNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCoverageModulationTableNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetShadingRateImageEnableNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRepresentativeFragmentTestEnableNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetCoverageReductionModeNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdOpticalFlowExecuteNV) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBindShadersEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetAttachmentFeedbackLoopEnableEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBuildAccelerationStructuresKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdBuildAccelerationStructuresIndirectKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyAccelerationStructureKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyAccelerationStructureToMemoryKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdCopyMemoryToAccelerationStructureKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdWriteAccelerationStructuresPropertiesKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdTraceRaysKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdTraceRaysIndirectKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdSetRayTracingPipelineStackSizeKHR) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMeshTasksEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMeshTasksIndirectEXT) \ + VK_USE_DEVICE_CMD_FUNCTION(vkCmdDrawMeshTasksIndirectCountEXT) \ + +#define VK_GLOBAL_FUNCTIONS \ + VK_USE_GLOBAL_FUNCTION(vkCreateInstance) \ + VK_USE_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties) \ + VK_USE_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties) \ + VK_USE_GLOBAL_FUNCTION(vkEnumerateInstanceVersion) \ + diff --git a/Src/RenderFramework/Vulkan/VulkanGlobalFunctions.h b/Src/RenderFramework/Vulkan/VulkanGlobalFunctions.h new file mode 100644 index 0000000..d445eb0 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanGlobalFunctions.h @@ -0,0 +1,3143 @@ +#pragma once +#include +#include +class VulkanGlobalFunctions { +public: + VulkanGlobalFunctions(std::function loader){ + _vkCreateInstance = reinterpret_cast(loader("vkCreateInstance")); + _vkDestroyInstance = reinterpret_cast(loader("vkDestroyInstance")); + _vkEnumeratePhysicalDevices = reinterpret_cast(loader("vkEnumeratePhysicalDevices")); + _vkGetPhysicalDeviceFeatures = reinterpret_cast(loader("vkGetPhysicalDeviceFeatures")); + _vkGetPhysicalDeviceFormatProperties = reinterpret_cast(loader("vkGetPhysicalDeviceFormatProperties")); + _vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast(loader("vkGetPhysicalDeviceImageFormatProperties")); + _vkGetPhysicalDeviceProperties = reinterpret_cast(loader("vkGetPhysicalDeviceProperties")); + _vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyProperties")); + _vkGetPhysicalDeviceMemoryProperties = reinterpret_cast(loader("vkGetPhysicalDeviceMemoryProperties")); + _vkGetInstanceProcAddr = reinterpret_cast(loader("vkGetInstanceProcAddr")); + _vkGetDeviceProcAddr = reinterpret_cast(loader("vkGetDeviceProcAddr")); + _vkCreateDevice = reinterpret_cast(loader("vkCreateDevice")); + _vkDestroyDevice = reinterpret_cast(loader("vkDestroyDevice")); + _vkEnumerateInstanceExtensionProperties = reinterpret_cast(loader("vkEnumerateInstanceExtensionProperties")); + _vkEnumerateDeviceExtensionProperties = reinterpret_cast(loader("vkEnumerateDeviceExtensionProperties")); + _vkEnumerateInstanceLayerProperties = reinterpret_cast(loader("vkEnumerateInstanceLayerProperties")); + _vkEnumerateDeviceLayerProperties = reinterpret_cast(loader("vkEnumerateDeviceLayerProperties")); + _vkGetDeviceQueue = reinterpret_cast(loader("vkGetDeviceQueue")); + _vkQueueSubmit = reinterpret_cast(loader("vkQueueSubmit")); + _vkQueueWaitIdle = reinterpret_cast(loader("vkQueueWaitIdle")); + _vkDeviceWaitIdle = reinterpret_cast(loader("vkDeviceWaitIdle")); + _vkAllocateMemory = reinterpret_cast(loader("vkAllocateMemory")); + _vkFreeMemory = reinterpret_cast(loader("vkFreeMemory")); + _vkMapMemory = reinterpret_cast(loader("vkMapMemory")); + _vkUnmapMemory = reinterpret_cast(loader("vkUnmapMemory")); + _vkFlushMappedMemoryRanges = reinterpret_cast(loader("vkFlushMappedMemoryRanges")); + _vkInvalidateMappedMemoryRanges = reinterpret_cast(loader("vkInvalidateMappedMemoryRanges")); + _vkGetDeviceMemoryCommitment = reinterpret_cast(loader("vkGetDeviceMemoryCommitment")); + _vkBindBufferMemory = reinterpret_cast(loader("vkBindBufferMemory")); + _vkBindImageMemory = reinterpret_cast(loader("vkBindImageMemory")); + _vkGetBufferMemoryRequirements = reinterpret_cast(loader("vkGetBufferMemoryRequirements")); + _vkGetImageMemoryRequirements = reinterpret_cast(loader("vkGetImageMemoryRequirements")); + _vkGetImageSparseMemoryRequirements = reinterpret_cast(loader("vkGetImageSparseMemoryRequirements")); + _vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast(loader("vkGetPhysicalDeviceSparseImageFormatProperties")); + _vkQueueBindSparse = reinterpret_cast(loader("vkQueueBindSparse")); + _vkCreateFence = reinterpret_cast(loader("vkCreateFence")); + _vkDestroyFence = reinterpret_cast(loader("vkDestroyFence")); + _vkResetFences = reinterpret_cast(loader("vkResetFences")); + _vkGetFenceStatus = reinterpret_cast(loader("vkGetFenceStatus")); + _vkWaitForFences = reinterpret_cast(loader("vkWaitForFences")); + _vkCreateSemaphore = reinterpret_cast(loader("vkCreateSemaphore")); + _vkDestroySemaphore = reinterpret_cast(loader("vkDestroySemaphore")); + _vkCreateEvent = reinterpret_cast(loader("vkCreateEvent")); + _vkDestroyEvent = reinterpret_cast(loader("vkDestroyEvent")); + _vkGetEventStatus = reinterpret_cast(loader("vkGetEventStatus")); + _vkSetEvent = reinterpret_cast(loader("vkSetEvent")); + _vkResetEvent = reinterpret_cast(loader("vkResetEvent")); + _vkCreateQueryPool = reinterpret_cast(loader("vkCreateQueryPool")); + _vkDestroyQueryPool = reinterpret_cast(loader("vkDestroyQueryPool")); + _vkGetQueryPoolResults = reinterpret_cast(loader("vkGetQueryPoolResults")); + _vkCreateBuffer = reinterpret_cast(loader("vkCreateBuffer")); + _vkDestroyBuffer = reinterpret_cast(loader("vkDestroyBuffer")); + _vkCreateBufferView = reinterpret_cast(loader("vkCreateBufferView")); + _vkDestroyBufferView = reinterpret_cast(loader("vkDestroyBufferView")); + _vkCreateImage = reinterpret_cast(loader("vkCreateImage")); + _vkDestroyImage = reinterpret_cast(loader("vkDestroyImage")); + _vkGetImageSubresourceLayout = reinterpret_cast(loader("vkGetImageSubresourceLayout")); + _vkCreateImageView = reinterpret_cast(loader("vkCreateImageView")); + _vkDestroyImageView = reinterpret_cast(loader("vkDestroyImageView")); + _vkCreateShaderModule = reinterpret_cast(loader("vkCreateShaderModule")); + _vkDestroyShaderModule = reinterpret_cast(loader("vkDestroyShaderModule")); + _vkCreatePipelineCache = reinterpret_cast(loader("vkCreatePipelineCache")); + _vkDestroyPipelineCache = reinterpret_cast(loader("vkDestroyPipelineCache")); + _vkGetPipelineCacheData = reinterpret_cast(loader("vkGetPipelineCacheData")); + _vkMergePipelineCaches = reinterpret_cast(loader("vkMergePipelineCaches")); + _vkCreateGraphicsPipelines = reinterpret_cast(loader("vkCreateGraphicsPipelines")); + _vkCreateComputePipelines = reinterpret_cast(loader("vkCreateComputePipelines")); + _vkDestroyPipeline = reinterpret_cast(loader("vkDestroyPipeline")); + _vkCreatePipelineLayout = reinterpret_cast(loader("vkCreatePipelineLayout")); + _vkDestroyPipelineLayout = reinterpret_cast(loader("vkDestroyPipelineLayout")); + _vkCreateSampler = reinterpret_cast(loader("vkCreateSampler")); + _vkDestroySampler = reinterpret_cast(loader("vkDestroySampler")); + _vkCreateDescriptorSetLayout = reinterpret_cast(loader("vkCreateDescriptorSetLayout")); + _vkDestroyDescriptorSetLayout = reinterpret_cast(loader("vkDestroyDescriptorSetLayout")); + _vkCreateDescriptorPool = reinterpret_cast(loader("vkCreateDescriptorPool")); + _vkDestroyDescriptorPool = reinterpret_cast(loader("vkDestroyDescriptorPool")); + _vkResetDescriptorPool = reinterpret_cast(loader("vkResetDescriptorPool")); + _vkAllocateDescriptorSets = reinterpret_cast(loader("vkAllocateDescriptorSets")); + _vkFreeDescriptorSets = reinterpret_cast(loader("vkFreeDescriptorSets")); + _vkUpdateDescriptorSets = reinterpret_cast(loader("vkUpdateDescriptorSets")); + _vkCreateFramebuffer = reinterpret_cast(loader("vkCreateFramebuffer")); + _vkDestroyFramebuffer = reinterpret_cast(loader("vkDestroyFramebuffer")); + _vkCreateRenderPass = reinterpret_cast(loader("vkCreateRenderPass")); + _vkDestroyRenderPass = reinterpret_cast(loader("vkDestroyRenderPass")); + _vkGetRenderAreaGranularity = reinterpret_cast(loader("vkGetRenderAreaGranularity")); + _vkCreateCommandPool = reinterpret_cast(loader("vkCreateCommandPool")); + _vkDestroyCommandPool = reinterpret_cast(loader("vkDestroyCommandPool")); + _vkResetCommandPool = reinterpret_cast(loader("vkResetCommandPool")); + _vkAllocateCommandBuffers = reinterpret_cast(loader("vkAllocateCommandBuffers")); + _vkFreeCommandBuffers = reinterpret_cast(loader("vkFreeCommandBuffers")); + _vkBeginCommandBuffer = reinterpret_cast(loader("vkBeginCommandBuffer")); + _vkEndCommandBuffer = reinterpret_cast(loader("vkEndCommandBuffer")); + _vkResetCommandBuffer = reinterpret_cast(loader("vkResetCommandBuffer")); + _vkCmdBindPipeline = reinterpret_cast(loader("vkCmdBindPipeline")); + _vkCmdSetViewport = reinterpret_cast(loader("vkCmdSetViewport")); + _vkCmdSetScissor = reinterpret_cast(loader("vkCmdSetScissor")); + _vkCmdSetLineWidth = reinterpret_cast(loader("vkCmdSetLineWidth")); + _vkCmdSetDepthBias = reinterpret_cast(loader("vkCmdSetDepthBias")); + _vkCmdSetBlendConstants = reinterpret_cast(loader("vkCmdSetBlendConstants")); + _vkCmdSetDepthBounds = reinterpret_cast(loader("vkCmdSetDepthBounds")); + _vkCmdSetStencilCompareMask = reinterpret_cast(loader("vkCmdSetStencilCompareMask")); + _vkCmdSetStencilWriteMask = reinterpret_cast(loader("vkCmdSetStencilWriteMask")); + _vkCmdSetStencilReference = reinterpret_cast(loader("vkCmdSetStencilReference")); + _vkCmdBindDescriptorSets = reinterpret_cast(loader("vkCmdBindDescriptorSets")); + _vkCmdBindIndexBuffer = reinterpret_cast(loader("vkCmdBindIndexBuffer")); + _vkCmdBindVertexBuffers = reinterpret_cast(loader("vkCmdBindVertexBuffers")); + _vkCmdDraw = reinterpret_cast(loader("vkCmdDraw")); + _vkCmdDrawIndexed = reinterpret_cast(loader("vkCmdDrawIndexed")); + _vkCmdDrawIndirect = reinterpret_cast(loader("vkCmdDrawIndirect")); + _vkCmdDrawIndexedIndirect = reinterpret_cast(loader("vkCmdDrawIndexedIndirect")); + _vkCmdDispatch = reinterpret_cast(loader("vkCmdDispatch")); + _vkCmdDispatchIndirect = reinterpret_cast(loader("vkCmdDispatchIndirect")); + _vkCmdCopyBuffer = reinterpret_cast(loader("vkCmdCopyBuffer")); + _vkCmdCopyImage = reinterpret_cast(loader("vkCmdCopyImage")); + _vkCmdBlitImage = reinterpret_cast(loader("vkCmdBlitImage")); + _vkCmdCopyBufferToImage = reinterpret_cast(loader("vkCmdCopyBufferToImage")); + _vkCmdCopyImageToBuffer = reinterpret_cast(loader("vkCmdCopyImageToBuffer")); + _vkCmdUpdateBuffer = reinterpret_cast(loader("vkCmdUpdateBuffer")); + _vkCmdFillBuffer = reinterpret_cast(loader("vkCmdFillBuffer")); + _vkCmdClearColorImage = reinterpret_cast(loader("vkCmdClearColorImage")); + _vkCmdClearDepthStencilImage = reinterpret_cast(loader("vkCmdClearDepthStencilImage")); + _vkCmdClearAttachments = reinterpret_cast(loader("vkCmdClearAttachments")); + _vkCmdResolveImage = reinterpret_cast(loader("vkCmdResolveImage")); + _vkCmdSetEvent = reinterpret_cast(loader("vkCmdSetEvent")); + _vkCmdResetEvent = reinterpret_cast(loader("vkCmdResetEvent")); + _vkCmdWaitEvents = reinterpret_cast(loader("vkCmdWaitEvents")); + _vkCmdPipelineBarrier = reinterpret_cast(loader("vkCmdPipelineBarrier")); + _vkCmdBeginQuery = reinterpret_cast(loader("vkCmdBeginQuery")); + _vkCmdEndQuery = reinterpret_cast(loader("vkCmdEndQuery")); + _vkCmdResetQueryPool = reinterpret_cast(loader("vkCmdResetQueryPool")); + _vkCmdWriteTimestamp = reinterpret_cast(loader("vkCmdWriteTimestamp")); + _vkCmdCopyQueryPoolResults = reinterpret_cast(loader("vkCmdCopyQueryPoolResults")); + _vkCmdPushConstants = reinterpret_cast(loader("vkCmdPushConstants")); + _vkCmdBeginRenderPass = reinterpret_cast(loader("vkCmdBeginRenderPass")); + _vkCmdNextSubpass = reinterpret_cast(loader("vkCmdNextSubpass")); + _vkCmdEndRenderPass = reinterpret_cast(loader("vkCmdEndRenderPass")); + _vkCmdExecuteCommands = reinterpret_cast(loader("vkCmdExecuteCommands")); + _vkEnumerateInstanceVersion = reinterpret_cast(loader("vkEnumerateInstanceVersion")); + _vkBindBufferMemory2 = reinterpret_cast(loader("vkBindBufferMemory2")); + _vkBindImageMemory2 = reinterpret_cast(loader("vkBindImageMemory2")); + _vkGetDeviceGroupPeerMemoryFeatures = reinterpret_cast(loader("vkGetDeviceGroupPeerMemoryFeatures")); + _vkCmdSetDeviceMask = reinterpret_cast(loader("vkCmdSetDeviceMask")); + _vkCmdDispatchBase = reinterpret_cast(loader("vkCmdDispatchBase")); + _vkEnumeratePhysicalDeviceGroups = reinterpret_cast(loader("vkEnumeratePhysicalDeviceGroups")); + _vkGetImageMemoryRequirements2 = reinterpret_cast(loader("vkGetImageMemoryRequirements2")); + _vkGetBufferMemoryRequirements2 = reinterpret_cast(loader("vkGetBufferMemoryRequirements2")); + _vkGetImageSparseMemoryRequirements2 = reinterpret_cast(loader("vkGetImageSparseMemoryRequirements2")); + _vkGetPhysicalDeviceFeatures2 = reinterpret_cast(loader("vkGetPhysicalDeviceFeatures2")); + _vkGetPhysicalDeviceProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceProperties2")); + _vkGetPhysicalDeviceFormatProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceFormatProperties2")); + _vkGetPhysicalDeviceImageFormatProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceImageFormatProperties2")); + _vkGetPhysicalDeviceQueueFamilyProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyProperties2")); + _vkGetPhysicalDeviceMemoryProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceMemoryProperties2")); + _vkGetPhysicalDeviceSparseImageFormatProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceSparseImageFormatProperties2")); + _vkTrimCommandPool = reinterpret_cast(loader("vkTrimCommandPool")); + _vkGetDeviceQueue2 = reinterpret_cast(loader("vkGetDeviceQueue2")); + _vkCreateSamplerYcbcrConversion = reinterpret_cast(loader("vkCreateSamplerYcbcrConversion")); + _vkDestroySamplerYcbcrConversion = reinterpret_cast(loader("vkDestroySamplerYcbcrConversion")); + _vkCreateDescriptorUpdateTemplate = reinterpret_cast(loader("vkCreateDescriptorUpdateTemplate")); + _vkDestroyDescriptorUpdateTemplate = reinterpret_cast(loader("vkDestroyDescriptorUpdateTemplate")); + _vkUpdateDescriptorSetWithTemplate = reinterpret_cast(loader("vkUpdateDescriptorSetWithTemplate")); + _vkGetPhysicalDeviceExternalBufferProperties = reinterpret_cast(loader("vkGetPhysicalDeviceExternalBufferProperties")); + _vkGetPhysicalDeviceExternalFenceProperties = reinterpret_cast(loader("vkGetPhysicalDeviceExternalFenceProperties")); + _vkGetPhysicalDeviceExternalSemaphoreProperties = reinterpret_cast(loader("vkGetPhysicalDeviceExternalSemaphoreProperties")); + _vkGetDescriptorSetLayoutSupport = reinterpret_cast(loader("vkGetDescriptorSetLayoutSupport")); + _vkCmdDrawIndirectCount = reinterpret_cast(loader("vkCmdDrawIndirectCount")); + _vkCmdDrawIndexedIndirectCount = reinterpret_cast(loader("vkCmdDrawIndexedIndirectCount")); + _vkCreateRenderPass2 = reinterpret_cast(loader("vkCreateRenderPass2")); + _vkCmdBeginRenderPass2 = reinterpret_cast(loader("vkCmdBeginRenderPass2")); + _vkCmdNextSubpass2 = reinterpret_cast(loader("vkCmdNextSubpass2")); + _vkCmdEndRenderPass2 = reinterpret_cast(loader("vkCmdEndRenderPass2")); + _vkResetQueryPool = reinterpret_cast(loader("vkResetQueryPool")); + _vkGetSemaphoreCounterValue = reinterpret_cast(loader("vkGetSemaphoreCounterValue")); + _vkWaitSemaphores = reinterpret_cast(loader("vkWaitSemaphores")); + _vkSignalSemaphore = reinterpret_cast(loader("vkSignalSemaphore")); + _vkGetBufferDeviceAddress = reinterpret_cast(loader("vkGetBufferDeviceAddress")); + _vkGetBufferOpaqueCaptureAddress = reinterpret_cast(loader("vkGetBufferOpaqueCaptureAddress")); + _vkGetDeviceMemoryOpaqueCaptureAddress = reinterpret_cast(loader("vkGetDeviceMemoryOpaqueCaptureAddress")); + _vkGetPhysicalDeviceToolProperties = reinterpret_cast(loader("vkGetPhysicalDeviceToolProperties")); + _vkCreatePrivateDataSlot = reinterpret_cast(loader("vkCreatePrivateDataSlot")); + _vkDestroyPrivateDataSlot = reinterpret_cast(loader("vkDestroyPrivateDataSlot")); + _vkSetPrivateData = reinterpret_cast(loader("vkSetPrivateData")); + _vkGetPrivateData = reinterpret_cast(loader("vkGetPrivateData")); + _vkCmdSetEvent2 = reinterpret_cast(loader("vkCmdSetEvent2")); + _vkCmdResetEvent2 = reinterpret_cast(loader("vkCmdResetEvent2")); + _vkCmdWaitEvents2 = reinterpret_cast(loader("vkCmdWaitEvents2")); + _vkCmdPipelineBarrier2 = reinterpret_cast(loader("vkCmdPipelineBarrier2")); + _vkCmdWriteTimestamp2 = reinterpret_cast(loader("vkCmdWriteTimestamp2")); + _vkQueueSubmit2 = reinterpret_cast(loader("vkQueueSubmit2")); + _vkCmdCopyBuffer2 = reinterpret_cast(loader("vkCmdCopyBuffer2")); + _vkCmdCopyImage2 = reinterpret_cast(loader("vkCmdCopyImage2")); + _vkCmdCopyBufferToImage2 = reinterpret_cast(loader("vkCmdCopyBufferToImage2")); + _vkCmdCopyImageToBuffer2 = reinterpret_cast(loader("vkCmdCopyImageToBuffer2")); + _vkCmdBlitImage2 = reinterpret_cast(loader("vkCmdBlitImage2")); + _vkCmdResolveImage2 = reinterpret_cast(loader("vkCmdResolveImage2")); + _vkCmdBeginRendering = reinterpret_cast(loader("vkCmdBeginRendering")); + _vkCmdEndRendering = reinterpret_cast(loader("vkCmdEndRendering")); + _vkCmdSetCullMode = reinterpret_cast(loader("vkCmdSetCullMode")); + _vkCmdSetFrontFace = reinterpret_cast(loader("vkCmdSetFrontFace")); + _vkCmdSetPrimitiveTopology = reinterpret_cast(loader("vkCmdSetPrimitiveTopology")); + _vkCmdSetViewportWithCount = reinterpret_cast(loader("vkCmdSetViewportWithCount")); + _vkCmdSetScissorWithCount = reinterpret_cast(loader("vkCmdSetScissorWithCount")); + _vkCmdBindVertexBuffers2 = reinterpret_cast(loader("vkCmdBindVertexBuffers2")); + _vkCmdSetDepthTestEnable = reinterpret_cast(loader("vkCmdSetDepthTestEnable")); + _vkCmdSetDepthWriteEnable = reinterpret_cast(loader("vkCmdSetDepthWriteEnable")); + _vkCmdSetDepthCompareOp = reinterpret_cast(loader("vkCmdSetDepthCompareOp")); + _vkCmdSetDepthBoundsTestEnable = reinterpret_cast(loader("vkCmdSetDepthBoundsTestEnable")); + _vkCmdSetStencilTestEnable = reinterpret_cast(loader("vkCmdSetStencilTestEnable")); + _vkCmdSetStencilOp = reinterpret_cast(loader("vkCmdSetStencilOp")); + _vkCmdSetRasterizerDiscardEnable = reinterpret_cast(loader("vkCmdSetRasterizerDiscardEnable")); + _vkCmdSetDepthBiasEnable = reinterpret_cast(loader("vkCmdSetDepthBiasEnable")); + _vkCmdSetPrimitiveRestartEnable = reinterpret_cast(loader("vkCmdSetPrimitiveRestartEnable")); + _vkGetDeviceBufferMemoryRequirements = reinterpret_cast(loader("vkGetDeviceBufferMemoryRequirements")); + _vkGetDeviceImageMemoryRequirements = reinterpret_cast(loader("vkGetDeviceImageMemoryRequirements")); + _vkGetDeviceImageSparseMemoryRequirements = reinterpret_cast(loader("vkGetDeviceImageSparseMemoryRequirements")); + _vkDestroySurfaceKHR = reinterpret_cast(loader("vkDestroySurfaceKHR")); + _vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceSupportKHR")); + _vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); + _vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceFormatsKHR")); + _vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfacePresentModesKHR")); + _vkCreateSwapchainKHR = reinterpret_cast(loader("vkCreateSwapchainKHR")); + _vkDestroySwapchainKHR = reinterpret_cast(loader("vkDestroySwapchainKHR")); + _vkGetSwapchainImagesKHR = reinterpret_cast(loader("vkGetSwapchainImagesKHR")); + _vkAcquireNextImageKHR = reinterpret_cast(loader("vkAcquireNextImageKHR")); + _vkQueuePresentKHR = reinterpret_cast(loader("vkQueuePresentKHR")); + _vkGetDeviceGroupPresentCapabilitiesKHR = reinterpret_cast(loader("vkGetDeviceGroupPresentCapabilitiesKHR")); + _vkGetDeviceGroupSurfacePresentModesKHR = reinterpret_cast(loader("vkGetDeviceGroupSurfacePresentModesKHR")); + _vkGetPhysicalDevicePresentRectanglesKHR = reinterpret_cast(loader("vkGetPhysicalDevicePresentRectanglesKHR")); + _vkAcquireNextImage2KHR = reinterpret_cast(loader("vkAcquireNextImage2KHR")); + _vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayPropertiesKHR")); + _vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); + _vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast(loader("vkGetDisplayPlaneSupportedDisplaysKHR")); + _vkGetDisplayModePropertiesKHR = reinterpret_cast(loader("vkGetDisplayModePropertiesKHR")); + _vkCreateDisplayModeKHR = reinterpret_cast(loader("vkCreateDisplayModeKHR")); + _vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast(loader("vkGetDisplayPlaneCapabilitiesKHR")); + _vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast(loader("vkCreateDisplayPlaneSurfaceKHR")); + _vkCreateSharedSwapchainsKHR = reinterpret_cast(loader("vkCreateSharedSwapchainsKHR")); + _vkGetPhysicalDeviceVideoCapabilitiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceVideoCapabilitiesKHR")); + _vkGetPhysicalDeviceVideoFormatPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceVideoFormatPropertiesKHR")); + _vkCreateVideoSessionKHR = reinterpret_cast(loader("vkCreateVideoSessionKHR")); + _vkDestroyVideoSessionKHR = reinterpret_cast(loader("vkDestroyVideoSessionKHR")); + _vkGetVideoSessionMemoryRequirementsKHR = reinterpret_cast(loader("vkGetVideoSessionMemoryRequirementsKHR")); + _vkBindVideoSessionMemoryKHR = reinterpret_cast(loader("vkBindVideoSessionMemoryKHR")); + _vkCreateVideoSessionParametersKHR = reinterpret_cast(loader("vkCreateVideoSessionParametersKHR")); + _vkUpdateVideoSessionParametersKHR = reinterpret_cast(loader("vkUpdateVideoSessionParametersKHR")); + _vkDestroyVideoSessionParametersKHR = reinterpret_cast(loader("vkDestroyVideoSessionParametersKHR")); + _vkCmdBeginVideoCodingKHR = reinterpret_cast(loader("vkCmdBeginVideoCodingKHR")); + _vkCmdEndVideoCodingKHR = reinterpret_cast(loader("vkCmdEndVideoCodingKHR")); + _vkCmdControlVideoCodingKHR = reinterpret_cast(loader("vkCmdControlVideoCodingKHR")); + _vkCmdDecodeVideoKHR = reinterpret_cast(loader("vkCmdDecodeVideoKHR")); + _vkCmdBeginRenderingKHR = reinterpret_cast(loader("vkCmdBeginRenderingKHR")); + _vkCmdEndRenderingKHR = reinterpret_cast(loader("vkCmdEndRenderingKHR")); + _vkGetPhysicalDeviceFeatures2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceFeatures2KHR")); + _vkGetPhysicalDeviceProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceProperties2KHR")); + _vkGetPhysicalDeviceFormatProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceFormatProperties2KHR")); + _vkGetPhysicalDeviceImageFormatProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceImageFormatProperties2KHR")); + _vkGetPhysicalDeviceQueueFamilyProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyProperties2KHR")); + _vkGetPhysicalDeviceMemoryProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceMemoryProperties2KHR")); + _vkGetPhysicalDeviceSparseImageFormatProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); + _vkGetDeviceGroupPeerMemoryFeaturesKHR = reinterpret_cast(loader("vkGetDeviceGroupPeerMemoryFeaturesKHR")); + _vkCmdSetDeviceMaskKHR = reinterpret_cast(loader("vkCmdSetDeviceMaskKHR")); + _vkCmdDispatchBaseKHR = reinterpret_cast(loader("vkCmdDispatchBaseKHR")); + _vkTrimCommandPoolKHR = reinterpret_cast(loader("vkTrimCommandPoolKHR")); + _vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast(loader("vkEnumeratePhysicalDeviceGroupsKHR")); + _vkGetPhysicalDeviceExternalBufferPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceExternalBufferPropertiesKHR")); + _vkGetMemoryFdKHR = reinterpret_cast(loader("vkGetMemoryFdKHR")); + _vkGetMemoryFdPropertiesKHR = reinterpret_cast(loader("vkGetMemoryFdPropertiesKHR")); + _vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); + _vkImportSemaphoreFdKHR = reinterpret_cast(loader("vkImportSemaphoreFdKHR")); + _vkGetSemaphoreFdKHR = reinterpret_cast(loader("vkGetSemaphoreFdKHR")); + _vkCmdPushDescriptorSetKHR = reinterpret_cast(loader("vkCmdPushDescriptorSetKHR")); + _vkCmdPushDescriptorSetWithTemplateKHR = reinterpret_cast(loader("vkCmdPushDescriptorSetWithTemplateKHR")); + _vkCreateDescriptorUpdateTemplateKHR = reinterpret_cast(loader("vkCreateDescriptorUpdateTemplateKHR")); + _vkDestroyDescriptorUpdateTemplateKHR = reinterpret_cast(loader("vkDestroyDescriptorUpdateTemplateKHR")); + _vkUpdateDescriptorSetWithTemplateKHR = reinterpret_cast(loader("vkUpdateDescriptorSetWithTemplateKHR")); + _vkCreateRenderPass2KHR = reinterpret_cast(loader("vkCreateRenderPass2KHR")); + _vkCmdBeginRenderPass2KHR = reinterpret_cast(loader("vkCmdBeginRenderPass2KHR")); + _vkCmdNextSubpass2KHR = reinterpret_cast(loader("vkCmdNextSubpass2KHR")); + _vkCmdEndRenderPass2KHR = reinterpret_cast(loader("vkCmdEndRenderPass2KHR")); + _vkGetSwapchainStatusKHR = reinterpret_cast(loader("vkGetSwapchainStatusKHR")); + _vkGetPhysicalDeviceExternalFencePropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceExternalFencePropertiesKHR")); + _vkImportFenceFdKHR = reinterpret_cast(loader("vkImportFenceFdKHR")); + _vkGetFenceFdKHR = reinterpret_cast(loader("vkGetFenceFdKHR")); + _vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = reinterpret_cast(loader("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); + _vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); + _vkAcquireProfilingLockKHR = reinterpret_cast(loader("vkAcquireProfilingLockKHR")); + _vkReleaseProfilingLockKHR = reinterpret_cast(loader("vkReleaseProfilingLockKHR")); + _vkGetPhysicalDeviceSurfaceCapabilities2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceCapabilities2KHR")); + _vkGetPhysicalDeviceSurfaceFormats2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceFormats2KHR")); + _vkGetPhysicalDeviceDisplayProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayProperties2KHR")); + _vkGetPhysicalDeviceDisplayPlaneProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); + _vkGetDisplayModeProperties2KHR = reinterpret_cast(loader("vkGetDisplayModeProperties2KHR")); + _vkGetDisplayPlaneCapabilities2KHR = reinterpret_cast(loader("vkGetDisplayPlaneCapabilities2KHR")); + _vkGetImageMemoryRequirements2KHR = reinterpret_cast(loader("vkGetImageMemoryRequirements2KHR")); + _vkGetBufferMemoryRequirements2KHR = reinterpret_cast(loader("vkGetBufferMemoryRequirements2KHR")); + _vkGetImageSparseMemoryRequirements2KHR = reinterpret_cast(loader("vkGetImageSparseMemoryRequirements2KHR")); + _vkCreateSamplerYcbcrConversionKHR = reinterpret_cast(loader("vkCreateSamplerYcbcrConversionKHR")); + _vkDestroySamplerYcbcrConversionKHR = reinterpret_cast(loader("vkDestroySamplerYcbcrConversionKHR")); + _vkBindBufferMemory2KHR = reinterpret_cast(loader("vkBindBufferMemory2KHR")); + _vkBindImageMemory2KHR = reinterpret_cast(loader("vkBindImageMemory2KHR")); + _vkGetDescriptorSetLayoutSupportKHR = reinterpret_cast(loader("vkGetDescriptorSetLayoutSupportKHR")); + _vkCmdDrawIndirectCountKHR = reinterpret_cast(loader("vkCmdDrawIndirectCountKHR")); + _vkCmdDrawIndexedIndirectCountKHR = reinterpret_cast(loader("vkCmdDrawIndexedIndirectCountKHR")); + _vkGetSemaphoreCounterValueKHR = reinterpret_cast(loader("vkGetSemaphoreCounterValueKHR")); + _vkWaitSemaphoresKHR = reinterpret_cast(loader("vkWaitSemaphoresKHR")); + _vkSignalSemaphoreKHR = reinterpret_cast(loader("vkSignalSemaphoreKHR")); + _vkGetPhysicalDeviceFragmentShadingRatesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceFragmentShadingRatesKHR")); + _vkCmdSetFragmentShadingRateKHR = reinterpret_cast(loader("vkCmdSetFragmentShadingRateKHR")); + _vkCmdSetRenderingAttachmentLocationsKHR = reinterpret_cast(loader("vkCmdSetRenderingAttachmentLocationsKHR")); + _vkCmdSetRenderingInputAttachmentIndicesKHR = reinterpret_cast(loader("vkCmdSetRenderingInputAttachmentIndicesKHR")); + _vkWaitForPresentKHR = reinterpret_cast(loader("vkWaitForPresentKHR")); + _vkGetBufferDeviceAddressKHR = reinterpret_cast(loader("vkGetBufferDeviceAddressKHR")); + _vkGetBufferOpaqueCaptureAddressKHR = reinterpret_cast(loader("vkGetBufferOpaqueCaptureAddressKHR")); + _vkGetDeviceMemoryOpaqueCaptureAddressKHR = reinterpret_cast(loader("vkGetDeviceMemoryOpaqueCaptureAddressKHR")); + _vkCreateDeferredOperationKHR = reinterpret_cast(loader("vkCreateDeferredOperationKHR")); + _vkDestroyDeferredOperationKHR = reinterpret_cast(loader("vkDestroyDeferredOperationKHR")); + _vkGetDeferredOperationMaxConcurrencyKHR = reinterpret_cast(loader("vkGetDeferredOperationMaxConcurrencyKHR")); + _vkGetDeferredOperationResultKHR = reinterpret_cast(loader("vkGetDeferredOperationResultKHR")); + _vkDeferredOperationJoinKHR = reinterpret_cast(loader("vkDeferredOperationJoinKHR")); + _vkGetPipelineExecutablePropertiesKHR = reinterpret_cast(loader("vkGetPipelineExecutablePropertiesKHR")); + _vkGetPipelineExecutableStatisticsKHR = reinterpret_cast(loader("vkGetPipelineExecutableStatisticsKHR")); + _vkGetPipelineExecutableInternalRepresentationsKHR = reinterpret_cast(loader("vkGetPipelineExecutableInternalRepresentationsKHR")); + _vkMapMemory2KHR = reinterpret_cast(loader("vkMapMemory2KHR")); + _vkUnmapMemory2KHR = reinterpret_cast(loader("vkUnmapMemory2KHR")); + _vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")); + _vkGetEncodedVideoSessionParametersKHR = reinterpret_cast(loader("vkGetEncodedVideoSessionParametersKHR")); + _vkCmdEncodeVideoKHR = reinterpret_cast(loader("vkCmdEncodeVideoKHR")); + _vkCmdSetEvent2KHR = reinterpret_cast(loader("vkCmdSetEvent2KHR")); + _vkCmdResetEvent2KHR = reinterpret_cast(loader("vkCmdResetEvent2KHR")); + _vkCmdWaitEvents2KHR = reinterpret_cast(loader("vkCmdWaitEvents2KHR")); + _vkCmdPipelineBarrier2KHR = reinterpret_cast(loader("vkCmdPipelineBarrier2KHR")); + _vkCmdWriteTimestamp2KHR = reinterpret_cast(loader("vkCmdWriteTimestamp2KHR")); + _vkQueueSubmit2KHR = reinterpret_cast(loader("vkQueueSubmit2KHR")); + _vkCmdWriteBufferMarker2AMD = reinterpret_cast(loader("vkCmdWriteBufferMarker2AMD")); + _vkGetQueueCheckpointData2NV = reinterpret_cast(loader("vkGetQueueCheckpointData2NV")); + _vkCmdCopyBuffer2KHR = reinterpret_cast(loader("vkCmdCopyBuffer2KHR")); + _vkCmdCopyImage2KHR = reinterpret_cast(loader("vkCmdCopyImage2KHR")); + _vkCmdCopyBufferToImage2KHR = reinterpret_cast(loader("vkCmdCopyBufferToImage2KHR")); + _vkCmdCopyImageToBuffer2KHR = reinterpret_cast(loader("vkCmdCopyImageToBuffer2KHR")); + _vkCmdBlitImage2KHR = reinterpret_cast(loader("vkCmdBlitImage2KHR")); + _vkCmdResolveImage2KHR = reinterpret_cast(loader("vkCmdResolveImage2KHR")); + _vkCmdTraceRaysIndirect2KHR = reinterpret_cast(loader("vkCmdTraceRaysIndirect2KHR")); + _vkGetDeviceBufferMemoryRequirementsKHR = reinterpret_cast(loader("vkGetDeviceBufferMemoryRequirementsKHR")); + _vkGetDeviceImageMemoryRequirementsKHR = reinterpret_cast(loader("vkGetDeviceImageMemoryRequirementsKHR")); + _vkGetDeviceImageSparseMemoryRequirementsKHR = reinterpret_cast(loader("vkGetDeviceImageSparseMemoryRequirementsKHR")); + _vkCmdBindIndexBuffer2KHR = reinterpret_cast(loader("vkCmdBindIndexBuffer2KHR")); + _vkGetRenderingAreaGranularityKHR = reinterpret_cast(loader("vkGetRenderingAreaGranularityKHR")); + _vkGetDeviceImageSubresourceLayoutKHR = reinterpret_cast(loader("vkGetDeviceImageSubresourceLayoutKHR")); + _vkGetImageSubresourceLayout2KHR = reinterpret_cast(loader("vkGetImageSubresourceLayout2KHR")); + _vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")); + _vkCmdSetLineStippleKHR = reinterpret_cast(loader("vkCmdSetLineStippleKHR")); + _vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = reinterpret_cast(loader("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")); + _vkGetCalibratedTimestampsKHR = reinterpret_cast(loader("vkGetCalibratedTimestampsKHR")); + _vkCmdBindDescriptorSets2KHR = reinterpret_cast(loader("vkCmdBindDescriptorSets2KHR")); + _vkCmdPushConstants2KHR = reinterpret_cast(loader("vkCmdPushConstants2KHR")); + _vkCmdPushDescriptorSet2KHR = reinterpret_cast(loader("vkCmdPushDescriptorSet2KHR")); + _vkCmdPushDescriptorSetWithTemplate2KHR = reinterpret_cast(loader("vkCmdPushDescriptorSetWithTemplate2KHR")); + _vkCmdSetDescriptorBufferOffsets2EXT = reinterpret_cast(loader("vkCmdSetDescriptorBufferOffsets2EXT")); + _vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = reinterpret_cast(loader("vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")); + _vkCreateDebugReportCallbackEXT = reinterpret_cast(loader("vkCreateDebugReportCallbackEXT")); + _vkDestroyDebugReportCallbackEXT = reinterpret_cast(loader("vkDestroyDebugReportCallbackEXT")); + _vkDebugReportMessageEXT = reinterpret_cast(loader("vkDebugReportMessageEXT")); + _vkDebugMarkerSetObjectTagEXT = reinterpret_cast(loader("vkDebugMarkerSetObjectTagEXT")); + _vkDebugMarkerSetObjectNameEXT = reinterpret_cast(loader("vkDebugMarkerSetObjectNameEXT")); + _vkCmdDebugMarkerBeginEXT = reinterpret_cast(loader("vkCmdDebugMarkerBeginEXT")); + _vkCmdDebugMarkerEndEXT = reinterpret_cast(loader("vkCmdDebugMarkerEndEXT")); + _vkCmdDebugMarkerInsertEXT = reinterpret_cast(loader("vkCmdDebugMarkerInsertEXT")); + _vkCmdBindTransformFeedbackBuffersEXT = reinterpret_cast(loader("vkCmdBindTransformFeedbackBuffersEXT")); + _vkCmdBeginTransformFeedbackEXT = reinterpret_cast(loader("vkCmdBeginTransformFeedbackEXT")); + _vkCmdEndTransformFeedbackEXT = reinterpret_cast(loader("vkCmdEndTransformFeedbackEXT")); + _vkCmdBeginQueryIndexedEXT = reinterpret_cast(loader("vkCmdBeginQueryIndexedEXT")); + _vkCmdEndQueryIndexedEXT = reinterpret_cast(loader("vkCmdEndQueryIndexedEXT")); + _vkCmdDrawIndirectByteCountEXT = reinterpret_cast(loader("vkCmdDrawIndirectByteCountEXT")); + _vkCreateCuModuleNVX = reinterpret_cast(loader("vkCreateCuModuleNVX")); + _vkCreateCuFunctionNVX = reinterpret_cast(loader("vkCreateCuFunctionNVX")); + _vkDestroyCuModuleNVX = reinterpret_cast(loader("vkDestroyCuModuleNVX")); + _vkDestroyCuFunctionNVX = reinterpret_cast(loader("vkDestroyCuFunctionNVX")); + _vkCmdCuLaunchKernelNVX = reinterpret_cast(loader("vkCmdCuLaunchKernelNVX")); + _vkGetImageViewHandleNVX = reinterpret_cast(loader("vkGetImageViewHandleNVX")); + _vkGetImageViewAddressNVX = reinterpret_cast(loader("vkGetImageViewAddressNVX")); + _vkCmdDrawIndirectCountAMD = reinterpret_cast(loader("vkCmdDrawIndirectCountAMD")); + _vkCmdDrawIndexedIndirectCountAMD = reinterpret_cast(loader("vkCmdDrawIndexedIndirectCountAMD")); + _vkGetShaderInfoAMD = reinterpret_cast(loader("vkGetShaderInfoAMD")); + _vkGetPhysicalDeviceExternalImageFormatPropertiesNV = reinterpret_cast(loader("vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); + _vkCmdBeginConditionalRenderingEXT = reinterpret_cast(loader("vkCmdBeginConditionalRenderingEXT")); + _vkCmdEndConditionalRenderingEXT = reinterpret_cast(loader("vkCmdEndConditionalRenderingEXT")); + _vkCmdSetViewportWScalingNV = reinterpret_cast(loader("vkCmdSetViewportWScalingNV")); + _vkReleaseDisplayEXT = reinterpret_cast(loader("vkReleaseDisplayEXT")); + _vkGetPhysicalDeviceSurfaceCapabilities2EXT = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceCapabilities2EXT")); + _vkDisplayPowerControlEXT = reinterpret_cast(loader("vkDisplayPowerControlEXT")); + _vkRegisterDeviceEventEXT = reinterpret_cast(loader("vkRegisterDeviceEventEXT")); + _vkRegisterDisplayEventEXT = reinterpret_cast(loader("vkRegisterDisplayEventEXT")); + _vkGetSwapchainCounterEXT = reinterpret_cast(loader("vkGetSwapchainCounterEXT")); + _vkGetRefreshCycleDurationGOOGLE = reinterpret_cast(loader("vkGetRefreshCycleDurationGOOGLE")); + _vkGetPastPresentationTimingGOOGLE = reinterpret_cast(loader("vkGetPastPresentationTimingGOOGLE")); + _vkCmdSetDiscardRectangleEXT = reinterpret_cast(loader("vkCmdSetDiscardRectangleEXT")); + _vkCmdSetDiscardRectangleEnableEXT = reinterpret_cast(loader("vkCmdSetDiscardRectangleEnableEXT")); + _vkCmdSetDiscardRectangleModeEXT = reinterpret_cast(loader("vkCmdSetDiscardRectangleModeEXT")); + _vkSetHdrMetadataEXT = reinterpret_cast(loader("vkSetHdrMetadataEXT")); + _vkSetDebugUtilsObjectNameEXT = reinterpret_cast(loader("vkSetDebugUtilsObjectNameEXT")); + _vkSetDebugUtilsObjectTagEXT = reinterpret_cast(loader("vkSetDebugUtilsObjectTagEXT")); + _vkQueueBeginDebugUtilsLabelEXT = reinterpret_cast(loader("vkQueueBeginDebugUtilsLabelEXT")); + _vkQueueEndDebugUtilsLabelEXT = reinterpret_cast(loader("vkQueueEndDebugUtilsLabelEXT")); + _vkQueueInsertDebugUtilsLabelEXT = reinterpret_cast(loader("vkQueueInsertDebugUtilsLabelEXT")); + _vkCmdBeginDebugUtilsLabelEXT = reinterpret_cast(loader("vkCmdBeginDebugUtilsLabelEXT")); + _vkCmdEndDebugUtilsLabelEXT = reinterpret_cast(loader("vkCmdEndDebugUtilsLabelEXT")); + _vkCmdInsertDebugUtilsLabelEXT = reinterpret_cast(loader("vkCmdInsertDebugUtilsLabelEXT")); + _vkCreateDebugUtilsMessengerEXT = reinterpret_cast(loader("vkCreateDebugUtilsMessengerEXT")); + _vkDestroyDebugUtilsMessengerEXT = reinterpret_cast(loader("vkDestroyDebugUtilsMessengerEXT")); + _vkSubmitDebugUtilsMessageEXT = reinterpret_cast(loader("vkSubmitDebugUtilsMessageEXT")); + _vkCmdSetSampleLocationsEXT = reinterpret_cast(loader("vkCmdSetSampleLocationsEXT")); + _vkGetPhysicalDeviceMultisamplePropertiesEXT = reinterpret_cast(loader("vkGetPhysicalDeviceMultisamplePropertiesEXT")); + _vkGetImageDrmFormatModifierPropertiesEXT = reinterpret_cast(loader("vkGetImageDrmFormatModifierPropertiesEXT")); + _vkCreateValidationCacheEXT = reinterpret_cast(loader("vkCreateValidationCacheEXT")); + _vkDestroyValidationCacheEXT = reinterpret_cast(loader("vkDestroyValidationCacheEXT")); + _vkMergeValidationCachesEXT = reinterpret_cast(loader("vkMergeValidationCachesEXT")); + _vkGetValidationCacheDataEXT = reinterpret_cast(loader("vkGetValidationCacheDataEXT")); + _vkCmdBindShadingRateImageNV = reinterpret_cast(loader("vkCmdBindShadingRateImageNV")); + _vkCmdSetViewportShadingRatePaletteNV = reinterpret_cast(loader("vkCmdSetViewportShadingRatePaletteNV")); + _vkCmdSetCoarseSampleOrderNV = reinterpret_cast(loader("vkCmdSetCoarseSampleOrderNV")); + _vkCreateAccelerationStructureNV = reinterpret_cast(loader("vkCreateAccelerationStructureNV")); + _vkDestroyAccelerationStructureNV = reinterpret_cast(loader("vkDestroyAccelerationStructureNV")); + _vkGetAccelerationStructureMemoryRequirementsNV = reinterpret_cast(loader("vkGetAccelerationStructureMemoryRequirementsNV")); + _vkBindAccelerationStructureMemoryNV = reinterpret_cast(loader("vkBindAccelerationStructureMemoryNV")); + _vkCmdBuildAccelerationStructureNV = reinterpret_cast(loader("vkCmdBuildAccelerationStructureNV")); + _vkCmdCopyAccelerationStructureNV = reinterpret_cast(loader("vkCmdCopyAccelerationStructureNV")); + _vkCmdTraceRaysNV = reinterpret_cast(loader("vkCmdTraceRaysNV")); + _vkCreateRayTracingPipelinesNV = reinterpret_cast(loader("vkCreateRayTracingPipelinesNV")); + _vkGetRayTracingShaderGroupHandlesKHR = reinterpret_cast(loader("vkGetRayTracingShaderGroupHandlesKHR")); + _vkGetRayTracingShaderGroupHandlesNV = reinterpret_cast(loader("vkGetRayTracingShaderGroupHandlesNV")); + _vkGetAccelerationStructureHandleNV = reinterpret_cast(loader("vkGetAccelerationStructureHandleNV")); + _vkCmdWriteAccelerationStructuresPropertiesNV = reinterpret_cast(loader("vkCmdWriteAccelerationStructuresPropertiesNV")); + _vkCompileDeferredNV = reinterpret_cast(loader("vkCompileDeferredNV")); + _vkGetMemoryHostPointerPropertiesEXT = reinterpret_cast(loader("vkGetMemoryHostPointerPropertiesEXT")); + _vkCmdWriteBufferMarkerAMD = reinterpret_cast(loader("vkCmdWriteBufferMarkerAMD")); + _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = reinterpret_cast(loader("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); + _vkGetCalibratedTimestampsEXT = reinterpret_cast(loader("vkGetCalibratedTimestampsEXT")); + _vkCmdDrawMeshTasksNV = reinterpret_cast(loader("vkCmdDrawMeshTasksNV")); + _vkCmdDrawMeshTasksIndirectNV = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectNV")); + _vkCmdDrawMeshTasksIndirectCountNV = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectCountNV")); + _vkCmdSetExclusiveScissorEnableNV = reinterpret_cast(loader("vkCmdSetExclusiveScissorEnableNV")); + _vkCmdSetExclusiveScissorNV = reinterpret_cast(loader("vkCmdSetExclusiveScissorNV")); + _vkCmdSetCheckpointNV = reinterpret_cast(loader("vkCmdSetCheckpointNV")); + _vkGetQueueCheckpointDataNV = reinterpret_cast(loader("vkGetQueueCheckpointDataNV")); + _vkInitializePerformanceApiINTEL = reinterpret_cast(loader("vkInitializePerformanceApiINTEL")); + _vkUninitializePerformanceApiINTEL = reinterpret_cast(loader("vkUninitializePerformanceApiINTEL")); + _vkCmdSetPerformanceMarkerINTEL = reinterpret_cast(loader("vkCmdSetPerformanceMarkerINTEL")); + _vkCmdSetPerformanceStreamMarkerINTEL = reinterpret_cast(loader("vkCmdSetPerformanceStreamMarkerINTEL")); + _vkCmdSetPerformanceOverrideINTEL = reinterpret_cast(loader("vkCmdSetPerformanceOverrideINTEL")); + _vkAcquirePerformanceConfigurationINTEL = reinterpret_cast(loader("vkAcquirePerformanceConfigurationINTEL")); + _vkReleasePerformanceConfigurationINTEL = reinterpret_cast(loader("vkReleasePerformanceConfigurationINTEL")); + _vkQueueSetPerformanceConfigurationINTEL = reinterpret_cast(loader("vkQueueSetPerformanceConfigurationINTEL")); + _vkGetPerformanceParameterINTEL = reinterpret_cast(loader("vkGetPerformanceParameterINTEL")); + _vkSetLocalDimmingAMD = reinterpret_cast(loader("vkSetLocalDimmingAMD")); + _vkGetBufferDeviceAddressEXT = reinterpret_cast(loader("vkGetBufferDeviceAddressEXT")); + _vkGetPhysicalDeviceToolPropertiesEXT = reinterpret_cast(loader("vkGetPhysicalDeviceToolPropertiesEXT")); + _vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = reinterpret_cast(loader("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")); + _vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = reinterpret_cast(loader("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")); + _vkCreateHeadlessSurfaceEXT = reinterpret_cast(loader("vkCreateHeadlessSurfaceEXT")); + _vkCmdSetLineStippleEXT = reinterpret_cast(loader("vkCmdSetLineStippleEXT")); + _vkResetQueryPoolEXT = reinterpret_cast(loader("vkResetQueryPoolEXT")); + _vkCmdSetCullModeEXT = reinterpret_cast(loader("vkCmdSetCullModeEXT")); + _vkCmdSetFrontFaceEXT = reinterpret_cast(loader("vkCmdSetFrontFaceEXT")); + _vkCmdSetPrimitiveTopologyEXT = reinterpret_cast(loader("vkCmdSetPrimitiveTopologyEXT")); + _vkCmdSetViewportWithCountEXT = reinterpret_cast(loader("vkCmdSetViewportWithCountEXT")); + _vkCmdSetScissorWithCountEXT = reinterpret_cast(loader("vkCmdSetScissorWithCountEXT")); + _vkCmdBindVertexBuffers2EXT = reinterpret_cast(loader("vkCmdBindVertexBuffers2EXT")); + _vkCmdSetDepthTestEnableEXT = reinterpret_cast(loader("vkCmdSetDepthTestEnableEXT")); + _vkCmdSetDepthWriteEnableEXT = reinterpret_cast(loader("vkCmdSetDepthWriteEnableEXT")); + _vkCmdSetDepthCompareOpEXT = reinterpret_cast(loader("vkCmdSetDepthCompareOpEXT")); + _vkCmdSetDepthBoundsTestEnableEXT = reinterpret_cast(loader("vkCmdSetDepthBoundsTestEnableEXT")); + _vkCmdSetStencilTestEnableEXT = reinterpret_cast(loader("vkCmdSetStencilTestEnableEXT")); + _vkCmdSetStencilOpEXT = reinterpret_cast(loader("vkCmdSetStencilOpEXT")); + _vkCopyMemoryToImageEXT = reinterpret_cast(loader("vkCopyMemoryToImageEXT")); + _vkCopyImageToMemoryEXT = reinterpret_cast(loader("vkCopyImageToMemoryEXT")); + _vkCopyImageToImageEXT = reinterpret_cast(loader("vkCopyImageToImageEXT")); + _vkTransitionImageLayoutEXT = reinterpret_cast(loader("vkTransitionImageLayoutEXT")); + _vkGetImageSubresourceLayout2EXT = reinterpret_cast(loader("vkGetImageSubresourceLayout2EXT")); + _vkReleaseSwapchainImagesEXT = reinterpret_cast(loader("vkReleaseSwapchainImagesEXT")); + _vkGetGeneratedCommandsMemoryRequirementsNV = reinterpret_cast(loader("vkGetGeneratedCommandsMemoryRequirementsNV")); + _vkCmdPreprocessGeneratedCommandsNV = reinterpret_cast(loader("vkCmdPreprocessGeneratedCommandsNV")); + _vkCmdExecuteGeneratedCommandsNV = reinterpret_cast(loader("vkCmdExecuteGeneratedCommandsNV")); + _vkCmdBindPipelineShaderGroupNV = reinterpret_cast(loader("vkCmdBindPipelineShaderGroupNV")); + _vkCreateIndirectCommandsLayoutNV = reinterpret_cast(loader("vkCreateIndirectCommandsLayoutNV")); + _vkDestroyIndirectCommandsLayoutNV = reinterpret_cast(loader("vkDestroyIndirectCommandsLayoutNV")); + _vkCmdSetDepthBias2EXT = reinterpret_cast(loader("vkCmdSetDepthBias2EXT")); + _vkAcquireDrmDisplayEXT = reinterpret_cast(loader("vkAcquireDrmDisplayEXT")); + _vkGetDrmDisplayEXT = reinterpret_cast(loader("vkGetDrmDisplayEXT")); + _vkCreatePrivateDataSlotEXT = reinterpret_cast(loader("vkCreatePrivateDataSlotEXT")); + _vkDestroyPrivateDataSlotEXT = reinterpret_cast(loader("vkDestroyPrivateDataSlotEXT")); + _vkSetPrivateDataEXT = reinterpret_cast(loader("vkSetPrivateDataEXT")); + _vkGetPrivateDataEXT = reinterpret_cast(loader("vkGetPrivateDataEXT")); + _vkCreateCudaModuleNV = reinterpret_cast(loader("vkCreateCudaModuleNV")); + _vkGetCudaModuleCacheNV = reinterpret_cast(loader("vkGetCudaModuleCacheNV")); + _vkCreateCudaFunctionNV = reinterpret_cast(loader("vkCreateCudaFunctionNV")); + _vkDestroyCudaModuleNV = reinterpret_cast(loader("vkDestroyCudaModuleNV")); + _vkDestroyCudaFunctionNV = reinterpret_cast(loader("vkDestroyCudaFunctionNV")); + _vkCmdCudaLaunchKernelNV = reinterpret_cast(loader("vkCmdCudaLaunchKernelNV")); + _vkGetDescriptorSetLayoutSizeEXT = reinterpret_cast(loader("vkGetDescriptorSetLayoutSizeEXT")); + _vkGetDescriptorSetLayoutBindingOffsetEXT = reinterpret_cast(loader("vkGetDescriptorSetLayoutBindingOffsetEXT")); + _vkGetDescriptorEXT = reinterpret_cast(loader("vkGetDescriptorEXT")); + _vkCmdBindDescriptorBuffersEXT = reinterpret_cast(loader("vkCmdBindDescriptorBuffersEXT")); + _vkCmdSetDescriptorBufferOffsetsEXT = reinterpret_cast(loader("vkCmdSetDescriptorBufferOffsetsEXT")); + _vkCmdBindDescriptorBufferEmbeddedSamplersEXT = reinterpret_cast(loader("vkCmdBindDescriptorBufferEmbeddedSamplersEXT")); + _vkGetBufferOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetBufferOpaqueCaptureDescriptorDataEXT")); + _vkGetImageOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetImageOpaqueCaptureDescriptorDataEXT")); + _vkGetImageViewOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetImageViewOpaqueCaptureDescriptorDataEXT")); + _vkGetSamplerOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetSamplerOpaqueCaptureDescriptorDataEXT")); + _vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = reinterpret_cast(loader("vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")); + _vkCmdSetFragmentShadingRateEnumNV = reinterpret_cast(loader("vkCmdSetFragmentShadingRateEnumNV")); + _vkGetDeviceFaultInfoEXT = reinterpret_cast(loader("vkGetDeviceFaultInfoEXT")); + _vkCmdSetVertexInputEXT = reinterpret_cast(loader("vkCmdSetVertexInputEXT")); + _vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = reinterpret_cast(loader("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")); + _vkCmdSubpassShadingHUAWEI = reinterpret_cast(loader("vkCmdSubpassShadingHUAWEI")); + _vkCmdBindInvocationMaskHUAWEI = reinterpret_cast(loader("vkCmdBindInvocationMaskHUAWEI")); + _vkGetMemoryRemoteAddressNV = reinterpret_cast(loader("vkGetMemoryRemoteAddressNV")); + _vkGetPipelinePropertiesEXT = reinterpret_cast(loader("vkGetPipelinePropertiesEXT")); + _vkCmdSetPatchControlPointsEXT = reinterpret_cast(loader("vkCmdSetPatchControlPointsEXT")); + _vkCmdSetRasterizerDiscardEnableEXT = reinterpret_cast(loader("vkCmdSetRasterizerDiscardEnableEXT")); + _vkCmdSetDepthBiasEnableEXT = reinterpret_cast(loader("vkCmdSetDepthBiasEnableEXT")); + _vkCmdSetLogicOpEXT = reinterpret_cast(loader("vkCmdSetLogicOpEXT")); + _vkCmdSetPrimitiveRestartEnableEXT = reinterpret_cast(loader("vkCmdSetPrimitiveRestartEnableEXT")); + _vkCmdSetColorWriteEnableEXT = reinterpret_cast(loader("vkCmdSetColorWriteEnableEXT")); + _vkCmdDrawMultiEXT = reinterpret_cast(loader("vkCmdDrawMultiEXT")); + _vkCmdDrawMultiIndexedEXT = reinterpret_cast(loader("vkCmdDrawMultiIndexedEXT")); + _vkCreateMicromapEXT = reinterpret_cast(loader("vkCreateMicromapEXT")); + _vkDestroyMicromapEXT = reinterpret_cast(loader("vkDestroyMicromapEXT")); + _vkCmdBuildMicromapsEXT = reinterpret_cast(loader("vkCmdBuildMicromapsEXT")); + _vkBuildMicromapsEXT = reinterpret_cast(loader("vkBuildMicromapsEXT")); + _vkCopyMicromapEXT = reinterpret_cast(loader("vkCopyMicromapEXT")); + _vkCopyMicromapToMemoryEXT = reinterpret_cast(loader("vkCopyMicromapToMemoryEXT")); + _vkCopyMemoryToMicromapEXT = reinterpret_cast(loader("vkCopyMemoryToMicromapEXT")); + _vkWriteMicromapsPropertiesEXT = reinterpret_cast(loader("vkWriteMicromapsPropertiesEXT")); + _vkCmdCopyMicromapEXT = reinterpret_cast(loader("vkCmdCopyMicromapEXT")); + _vkCmdCopyMicromapToMemoryEXT = reinterpret_cast(loader("vkCmdCopyMicromapToMemoryEXT")); + _vkCmdCopyMemoryToMicromapEXT = reinterpret_cast(loader("vkCmdCopyMemoryToMicromapEXT")); + _vkCmdWriteMicromapsPropertiesEXT = reinterpret_cast(loader("vkCmdWriteMicromapsPropertiesEXT")); + _vkGetDeviceMicromapCompatibilityEXT = reinterpret_cast(loader("vkGetDeviceMicromapCompatibilityEXT")); + _vkGetMicromapBuildSizesEXT = reinterpret_cast(loader("vkGetMicromapBuildSizesEXT")); + _vkCmdDrawClusterHUAWEI = reinterpret_cast(loader("vkCmdDrawClusterHUAWEI")); + _vkCmdDrawClusterIndirectHUAWEI = reinterpret_cast(loader("vkCmdDrawClusterIndirectHUAWEI")); + _vkSetDeviceMemoryPriorityEXT = reinterpret_cast(loader("vkSetDeviceMemoryPriorityEXT")); + _vkGetDescriptorSetLayoutHostMappingInfoVALVE = reinterpret_cast(loader("vkGetDescriptorSetLayoutHostMappingInfoVALVE")); + _vkGetDescriptorSetHostMappingVALVE = reinterpret_cast(loader("vkGetDescriptorSetHostMappingVALVE")); + _vkCmdCopyMemoryIndirectNV = reinterpret_cast(loader("vkCmdCopyMemoryIndirectNV")); + _vkCmdCopyMemoryToImageIndirectNV = reinterpret_cast(loader("vkCmdCopyMemoryToImageIndirectNV")); + _vkCmdDecompressMemoryNV = reinterpret_cast(loader("vkCmdDecompressMemoryNV")); + _vkCmdDecompressMemoryIndirectCountNV = reinterpret_cast(loader("vkCmdDecompressMemoryIndirectCountNV")); + _vkGetPipelineIndirectMemoryRequirementsNV = reinterpret_cast(loader("vkGetPipelineIndirectMemoryRequirementsNV")); + _vkCmdUpdatePipelineIndirectBufferNV = reinterpret_cast(loader("vkCmdUpdatePipelineIndirectBufferNV")); + _vkGetPipelineIndirectDeviceAddressNV = reinterpret_cast(loader("vkGetPipelineIndirectDeviceAddressNV")); + _vkCmdSetDepthClampEnableEXT = reinterpret_cast(loader("vkCmdSetDepthClampEnableEXT")); + _vkCmdSetPolygonModeEXT = reinterpret_cast(loader("vkCmdSetPolygonModeEXT")); + _vkCmdSetRasterizationSamplesEXT = reinterpret_cast(loader("vkCmdSetRasterizationSamplesEXT")); + _vkCmdSetSampleMaskEXT = reinterpret_cast(loader("vkCmdSetSampleMaskEXT")); + _vkCmdSetAlphaToCoverageEnableEXT = reinterpret_cast(loader("vkCmdSetAlphaToCoverageEnableEXT")); + _vkCmdSetAlphaToOneEnableEXT = reinterpret_cast(loader("vkCmdSetAlphaToOneEnableEXT")); + _vkCmdSetLogicOpEnableEXT = reinterpret_cast(loader("vkCmdSetLogicOpEnableEXT")); + _vkCmdSetColorBlendEnableEXT = reinterpret_cast(loader("vkCmdSetColorBlendEnableEXT")); + _vkCmdSetColorBlendEquationEXT = reinterpret_cast(loader("vkCmdSetColorBlendEquationEXT")); + _vkCmdSetColorWriteMaskEXT = reinterpret_cast(loader("vkCmdSetColorWriteMaskEXT")); + _vkCmdSetTessellationDomainOriginEXT = reinterpret_cast(loader("vkCmdSetTessellationDomainOriginEXT")); + _vkCmdSetRasterizationStreamEXT = reinterpret_cast(loader("vkCmdSetRasterizationStreamEXT")); + _vkCmdSetConservativeRasterizationModeEXT = reinterpret_cast(loader("vkCmdSetConservativeRasterizationModeEXT")); + _vkCmdSetExtraPrimitiveOverestimationSizeEXT = reinterpret_cast(loader("vkCmdSetExtraPrimitiveOverestimationSizeEXT")); + _vkCmdSetDepthClipEnableEXT = reinterpret_cast(loader("vkCmdSetDepthClipEnableEXT")); + _vkCmdSetSampleLocationsEnableEXT = reinterpret_cast(loader("vkCmdSetSampleLocationsEnableEXT")); + _vkCmdSetColorBlendAdvancedEXT = reinterpret_cast(loader("vkCmdSetColorBlendAdvancedEXT")); + _vkCmdSetProvokingVertexModeEXT = reinterpret_cast(loader("vkCmdSetProvokingVertexModeEXT")); + _vkCmdSetLineRasterizationModeEXT = reinterpret_cast(loader("vkCmdSetLineRasterizationModeEXT")); + _vkCmdSetLineStippleEnableEXT = reinterpret_cast(loader("vkCmdSetLineStippleEnableEXT")); + _vkCmdSetDepthClipNegativeOneToOneEXT = reinterpret_cast(loader("vkCmdSetDepthClipNegativeOneToOneEXT")); + _vkCmdSetViewportWScalingEnableNV = reinterpret_cast(loader("vkCmdSetViewportWScalingEnableNV")); + _vkCmdSetViewportSwizzleNV = reinterpret_cast(loader("vkCmdSetViewportSwizzleNV")); + _vkCmdSetCoverageToColorEnableNV = reinterpret_cast(loader("vkCmdSetCoverageToColorEnableNV")); + _vkCmdSetCoverageToColorLocationNV = reinterpret_cast(loader("vkCmdSetCoverageToColorLocationNV")); + _vkCmdSetCoverageModulationModeNV = reinterpret_cast(loader("vkCmdSetCoverageModulationModeNV")); + _vkCmdSetCoverageModulationTableEnableNV = reinterpret_cast(loader("vkCmdSetCoverageModulationTableEnableNV")); + _vkCmdSetCoverageModulationTableNV = reinterpret_cast(loader("vkCmdSetCoverageModulationTableNV")); + _vkCmdSetShadingRateImageEnableNV = reinterpret_cast(loader("vkCmdSetShadingRateImageEnableNV")); + _vkCmdSetRepresentativeFragmentTestEnableNV = reinterpret_cast(loader("vkCmdSetRepresentativeFragmentTestEnableNV")); + _vkCmdSetCoverageReductionModeNV = reinterpret_cast(loader("vkCmdSetCoverageReductionModeNV")); + _vkGetShaderModuleIdentifierEXT = reinterpret_cast(loader("vkGetShaderModuleIdentifierEXT")); + _vkGetShaderModuleCreateInfoIdentifierEXT = reinterpret_cast(loader("vkGetShaderModuleCreateInfoIdentifierEXT")); + _vkGetPhysicalDeviceOpticalFlowImageFormatsNV = reinterpret_cast(loader("vkGetPhysicalDeviceOpticalFlowImageFormatsNV")); + _vkCreateOpticalFlowSessionNV = reinterpret_cast(loader("vkCreateOpticalFlowSessionNV")); + _vkDestroyOpticalFlowSessionNV = reinterpret_cast(loader("vkDestroyOpticalFlowSessionNV")); + _vkBindOpticalFlowSessionImageNV = reinterpret_cast(loader("vkBindOpticalFlowSessionImageNV")); + _vkCmdOpticalFlowExecuteNV = reinterpret_cast(loader("vkCmdOpticalFlowExecuteNV")); + _vkCreateShadersEXT = reinterpret_cast(loader("vkCreateShadersEXT")); + _vkDestroyShaderEXT = reinterpret_cast(loader("vkDestroyShaderEXT")); + _vkGetShaderBinaryDataEXT = reinterpret_cast(loader("vkGetShaderBinaryDataEXT")); + _vkCmdBindShadersEXT = reinterpret_cast(loader("vkCmdBindShadersEXT")); + _vkGetFramebufferTilePropertiesQCOM = reinterpret_cast(loader("vkGetFramebufferTilePropertiesQCOM")); + _vkGetDynamicRenderingTilePropertiesQCOM = reinterpret_cast(loader("vkGetDynamicRenderingTilePropertiesQCOM")); + _vkSetLatencySleepModeNV = reinterpret_cast(loader("vkSetLatencySleepModeNV")); + _vkLatencySleepNV = reinterpret_cast(loader("vkLatencySleepNV")); + _vkSetLatencyMarkerNV = reinterpret_cast(loader("vkSetLatencyMarkerNV")); + _vkGetLatencyTimingsNV = reinterpret_cast(loader("vkGetLatencyTimingsNV")); + _vkQueueNotifyOutOfBandNV = reinterpret_cast(loader("vkQueueNotifyOutOfBandNV")); + _vkCmdSetAttachmentFeedbackLoopEnableEXT = reinterpret_cast(loader("vkCmdSetAttachmentFeedbackLoopEnableEXT")); + _vkCreateAccelerationStructureKHR = reinterpret_cast(loader("vkCreateAccelerationStructureKHR")); + _vkDestroyAccelerationStructureKHR = reinterpret_cast(loader("vkDestroyAccelerationStructureKHR")); + _vkCmdBuildAccelerationStructuresKHR = reinterpret_cast(loader("vkCmdBuildAccelerationStructuresKHR")); + _vkCmdBuildAccelerationStructuresIndirectKHR = reinterpret_cast(loader("vkCmdBuildAccelerationStructuresIndirectKHR")); + _vkBuildAccelerationStructuresKHR = reinterpret_cast(loader("vkBuildAccelerationStructuresKHR")); + _vkCopyAccelerationStructureKHR = reinterpret_cast(loader("vkCopyAccelerationStructureKHR")); + _vkCopyAccelerationStructureToMemoryKHR = reinterpret_cast(loader("vkCopyAccelerationStructureToMemoryKHR")); + _vkCopyMemoryToAccelerationStructureKHR = reinterpret_cast(loader("vkCopyMemoryToAccelerationStructureKHR")); + _vkWriteAccelerationStructuresPropertiesKHR = reinterpret_cast(loader("vkWriteAccelerationStructuresPropertiesKHR")); + _vkCmdCopyAccelerationStructureKHR = reinterpret_cast(loader("vkCmdCopyAccelerationStructureKHR")); + _vkCmdCopyAccelerationStructureToMemoryKHR = reinterpret_cast(loader("vkCmdCopyAccelerationStructureToMemoryKHR")); + _vkCmdCopyMemoryToAccelerationStructureKHR = reinterpret_cast(loader("vkCmdCopyMemoryToAccelerationStructureKHR")); + _vkGetAccelerationStructureDeviceAddressKHR = reinterpret_cast(loader("vkGetAccelerationStructureDeviceAddressKHR")); + _vkCmdWriteAccelerationStructuresPropertiesKHR = reinterpret_cast(loader("vkCmdWriteAccelerationStructuresPropertiesKHR")); + _vkGetDeviceAccelerationStructureCompatibilityKHR = reinterpret_cast(loader("vkGetDeviceAccelerationStructureCompatibilityKHR")); + _vkGetAccelerationStructureBuildSizesKHR = reinterpret_cast(loader("vkGetAccelerationStructureBuildSizesKHR")); + _vkCmdTraceRaysKHR = reinterpret_cast(loader("vkCmdTraceRaysKHR")); + _vkCreateRayTracingPipelinesKHR = reinterpret_cast(loader("vkCreateRayTracingPipelinesKHR")); + _vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = reinterpret_cast(loader("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")); + _vkCmdTraceRaysIndirectKHR = reinterpret_cast(loader("vkCmdTraceRaysIndirectKHR")); + _vkGetRayTracingShaderGroupStackSizeKHR = reinterpret_cast(loader("vkGetRayTracingShaderGroupStackSizeKHR")); + _vkCmdSetRayTracingPipelineStackSizeKHR = reinterpret_cast(loader("vkCmdSetRayTracingPipelineStackSizeKHR")); + _vkCmdDrawMeshTasksEXT = reinterpret_cast(loader("vkCmdDrawMeshTasksEXT")); + _vkCmdDrawMeshTasksIndirectEXT = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectEXT")); + _vkCmdDrawMeshTasksIndirectCountEXT = reinterpret_cast(loader("vkCmdDrawMeshTasksIndirectCountEXT")); + + } + VulkanGlobalFunctions(){} + VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) const { + return _vkCreateInstance(pCreateInfo, pAllocator, pInstance); + } + void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyInstance(instance, pAllocator); + } + VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const { + return _vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); + } + void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const { + _vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const { + _vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) const { + return _vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + } + void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const { + _vkGetPhysicalDeviceProperties(physicalDevice, pProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) const { + _vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const { + _vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); + } + PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) const { + return _vkGetInstanceProcAddr(instance, pName); + } + PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) const { + return _vkGetDeviceProcAddr(device, pName); + } + VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) const { + return _vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); + } + void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDevice(device, pAllocator); + } + VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) const { + return _vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties); + } + VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) const { + return _vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); + } + VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) const { + return _vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties); + } + VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) const { + return _vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); + } + void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) const { + _vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); + } + VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) const { + return _vkQueueSubmit(queue, submitCount, pSubmits, fence); + } + VkResult vkQueueWaitIdle(VkQueue queue) const { + return _vkQueueWaitIdle(queue); + } + VkResult vkDeviceWaitIdle(VkDevice device) const { + return _vkDeviceWaitIdle(device); + } + VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) const { + return _vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory); + } + void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) const { + _vkFreeMemory(device, memory, pAllocator); + } + VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const { + return _vkMapMemory(device, memory, offset, size, flags, ppData); + } + void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) const { + _vkUnmapMemory(device, memory); + } + VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const { + return _vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + } + VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const { + return _vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + } + void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const { + _vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); + } + VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const { + return _vkBindBufferMemory(device, buffer, memory, memoryOffset); + } + VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const { + return _vkBindImageMemory(device, image, memory, memoryOffset); + } + void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const { + _vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); + } + void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) const { + _vkGetImageMemoryRequirements(device, image, pMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const { + _vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) const { + _vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + } + VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) const { + return _vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + } + VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const { + return _vkCreateFence(device, pCreateInfo, pAllocator, pFence); + } + void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyFence(device, fence, pAllocator); + } + VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) const { + return _vkResetFences(device, fenceCount, pFences); + } + VkResult vkGetFenceStatus(VkDevice device, VkFence fence) const { + return _vkGetFenceStatus(device, fence); + } + VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) const { + return _vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); + } + VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) const { + return _vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); + } + void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySemaphore(device, semaphore, pAllocator); + } + VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) const { + return _vkCreateEvent(device, pCreateInfo, pAllocator, pEvent); + } + void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyEvent(device, event, pAllocator); + } + VkResult vkGetEventStatus(VkDevice device, VkEvent event) const { + return _vkGetEventStatus(device, event); + } + VkResult vkSetEvent(VkDevice device, VkEvent event) const { + return _vkSetEvent(device, event); + } + VkResult vkResetEvent(VkDevice device, VkEvent event) const { + return _vkResetEvent(device, event); + } + VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const { + return _vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); + } + void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyQueryPool(device, queryPool, pAllocator); + } + VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const { + return _vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + } + VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const { + return _vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); + } + void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyBuffer(device, buffer, pAllocator); + } + VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const { + return _vkCreateBufferView(device, pCreateInfo, pAllocator, pView); + } + void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyBufferView(device, bufferView, pAllocator); + } + VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) const { + return _vkCreateImage(device, pCreateInfo, pAllocator, pImage); + } + void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyImage(device, image, pAllocator); + } + void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const { + _vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); + } + VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) const { + return _vkCreateImageView(device, pCreateInfo, pAllocator, pView); + } + void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyImageView(device, imageView, pAllocator); + } + VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) const { + return _vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); + } + void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyShaderModule(device, shaderModule, pAllocator); + } + VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) const { + return _vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); + } + void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPipelineCache(device, pipelineCache, pAllocator); + } + VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) const { + return _vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData); + } + VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) const { + return _vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); + } + VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPipeline(device, pipeline, pAllocator); + } + VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) const { + return _vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); + } + void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPipelineLayout(device, pipelineLayout, pAllocator); + } + VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) const { + return _vkCreateSampler(device, pCreateInfo, pAllocator, pSampler); + } + void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySampler(device, sampler, pAllocator); + } + VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) const { + return _vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); + } + void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); + } + VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) const { + return _vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); + } + void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorPool(device, descriptorPool, pAllocator); + } + VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const { + return _vkResetDescriptorPool(device, descriptorPool, flags); + } + VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) const { + return _vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); + } + VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) const { + return _vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); + } + void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) const { + _vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + } + VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) const { + return _vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); + } + void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyFramebuffer(device, framebuffer, pAllocator); + } + VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const { + return _vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); + } + void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyRenderPass(device, renderPass, pAllocator); + } + void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const { + _vkGetRenderAreaGranularity(device, renderPass, pGranularity); + } + VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) const { + return _vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); + } + void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCommandPool(device, commandPool, pAllocator); + } + VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const { + return _vkResetCommandPool(device, commandPool, flags); + } + VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) const { + return _vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); + } + void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const { + _vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); + } + VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) const { + return _vkBeginCommandBuffer(commandBuffer, pBeginInfo); + } + VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) const { + return _vkEndCommandBuffer(commandBuffer); + } + VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const { + return _vkResetCommandBuffer(commandBuffer, flags); + } + void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const { + _vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); + } + void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) const { + _vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); + } + void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) const { + _vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); + } + void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const { + _vkCmdSetLineWidth(commandBuffer, lineWidth); + } + void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const { + _vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + } + void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const { + _vkCmdSetBlendConstants(commandBuffer, blendConstants); + } + void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const { + _vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); + } + void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const { + _vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); + } + void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const { + _vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); + } + void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const { + _vkCmdSetStencilReference(commandBuffer, faceMask, reference); + } + void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) const { + _vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + } + void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const { + _vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); + } + void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const { + _vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + } + void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const { + _vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + } + void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const { + _vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + } + void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const { + _vkCmdDispatchIndirect(commandBuffer, buffer, offset); + } + void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) const { + _vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + } + void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) const { + _vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) const { + _vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + } + void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) const { + _vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) const { + _vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + } + void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) const { + _vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); + } + void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const { + _vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); + } + void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const { + _vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + } + void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const { + _vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + } + void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) const { + _vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + } + void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) const { + _vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + } + void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const { + _vkCmdSetEvent(commandBuffer, event, stageMask); + } + void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const { + _vkCmdResetEvent(commandBuffer, event, stageMask); + } + void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const { + _vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + } + void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const { + _vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + } + void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const { + _vkCmdBeginQuery(commandBuffer, queryPool, query, flags); + } + void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const { + _vkCmdEndQuery(commandBuffer, queryPool, query); + } + void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const { + _vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); + } + void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) const { + _vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); + } + void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const { + _vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + } + void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) const { + _vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); + } + void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const { + _vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); + } + void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const { + _vkCmdNextSubpass(commandBuffer, contents); + } + void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const { + _vkCmdEndRenderPass(commandBuffer); + } + void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const { + _vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); + } + VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion) const { + return _vkEnumerateInstanceVersion(pApiVersion); + } + VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const { + return _vkBindBufferMemory2(device, bindInfoCount, pBindInfos); + } + VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const { + return _vkBindImageMemory2(device, bindInfoCount, pBindInfos); + } + void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const { + _vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + } + void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const { + _vkCmdSetDeviceMask(commandBuffer, deviceMask); + } + void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } + VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const { + return _vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + } + void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); + } + void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const { + _vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const { + _vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); + } + void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const { + _vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const { + return _vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const { + _vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const { + _vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const { + _vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } + void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const { + _vkTrimCommandPool(device, commandPool, flags); + } + void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const { + _vkGetDeviceQueue2(device, pQueueInfo, pQueue); + } + VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const { + return _vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); + } + void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); + } + VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const { + return _vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + } + void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); + } + void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const { + _vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); + } + void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const { + _vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + } + void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const { + _vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + } + void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const { + _vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + } + void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const { + _vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); + } + void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + VkResult vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const { + return _vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); + } + void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) const { + _vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + } + void vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + } + void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo); + } + void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const { + _vkResetQueryPool(device, queryPool, firstQuery, queryCount); + } + VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) const { + return _vkGetSemaphoreCounterValue(device, semaphore, pValue); + } + VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) const { + return _vkWaitSemaphores(device, pWaitInfo, timeout); + } + VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) const { + return _vkSignalSemaphore(device, pSignalInfo); + } + VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferDeviceAddress(device, pInfo); + } + uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferOpaqueCaptureAddress(device, pInfo); + } + uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const { + return _vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo); + } + VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) const { + return _vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); + } + VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) const { + return _vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); + } + void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator); + } + VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const { + return _vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data); + } + void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) const { + _vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); + } + void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdSetEvent2(commandBuffer, event, pDependencyInfo); + } + void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const { + _vkCmdResetEvent2(commandBuffer, event, stageMask); + } + void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) const { + _vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); + } + void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo); + } + void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const { + _vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query); + } + VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) const { + return _vkQueueSubmit2(queue, submitCount, pSubmits, fence); + } + void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) const { + _vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo); + } + void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) const { + _vkCmdCopyImage2(commandBuffer, pCopyImageInfo); + } + void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) const { + _vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); + } + void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) const { + _vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); + } + void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) const { + _vkCmdBlitImage2(commandBuffer, pBlitImageInfo); + } + void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) const { + _vkCmdResolveImage2(commandBuffer, pResolveImageInfo); + } + void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) const { + _vkCmdBeginRendering(commandBuffer, pRenderingInfo); + } + void vkCmdEndRendering(VkCommandBuffer commandBuffer) const { + _vkCmdEndRendering(commandBuffer); + } + void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const { + _vkCmdSetCullMode(commandBuffer, cullMode); + } + void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const { + _vkCmdSetFrontFace(commandBuffer, frontFace); + } + void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const { + _vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology); + } + void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const { + _vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); + } + void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const { + _vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); + } + void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const { + _vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + } + void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const { + _vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable); + } + void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const { + _vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); + } + void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const { + _vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp); + } + void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const { + _vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); + } + void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const { + _vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable); + } + void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const { + _vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + } + void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const { + _vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); + } + void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const { + _vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); + } + void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const { + _vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); + } + void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySurfaceKHR(instance, surface, pAllocator); + } + VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) const { + return _vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) const { + return _vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); + } + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) const { + return _vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); + } + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) const { + return _vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); + } + VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) const { + return _vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); + } + void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySwapchainKHR(device, swapchain, pAllocator); + } + VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) const { + return _vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); + } + VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) const { + return _vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); + } + VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const { + return _vkQueuePresentKHR(queue, pPresentInfo); + } + VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const { + return _vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); + } + VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) const { + return _vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); + } + VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) const { + return _vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); + } + VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) const { + return _vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); + } + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) const { + return _vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); + } + VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) const { + return _vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); + } + VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) const { + return _vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); + } + VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) const { + return _vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); + } + VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { + return _vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + } + VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const { + return _vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + } + VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) const { + return _vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); + } + VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) const { + return _vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); + } + VkResult vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) const { + return _vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); + } + void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyVideoSessionKHR(device, videoSession, pAllocator); + } + VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) const { + return _vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); + } + VkResult vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) const { + return _vkBindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + } + VkResult vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) const { + return _vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); + } + VkResult vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const { + return _vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); + } + void vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); + } + void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) const { + _vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); + } + void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) const { + _vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); + } + void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) const { + _vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); + } + void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) const { + _vkCmdDecodeVideoKHR(commandBuffer, pDecodeInfo); + } + void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) const { + _vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo); + } + void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) const { + _vkCmdEndRenderingKHR(commandBuffer); + } + void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const { + _vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const { + _vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); + } + void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const { + _vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const { + return _vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const { + _vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const { + _vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const { + _vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } + void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const { + _vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + } + void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const { + _vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask); + } + void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } + void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const { + _vkTrimCommandPoolKHR(device, commandPool, flags); + } + VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const { + return _vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + } + void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const { + _vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + } + VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const { + return _vkGetMemoryFdKHR(device, pGetFdInfo, pFd); + } + VkResult vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) const { + return _vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); + } + void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const { + _vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + } + VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const { + return _vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + } + VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const { + return _vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd); + } + void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const { + _vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + } + void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) const { + _vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } + VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const { + return _vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + } + void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); + } + void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const { + _vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); + } + VkResult vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const { + return _vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); + } + void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) const { + _vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + } + void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + } + void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) const { + _vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); + } + VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) const { + return _vkGetSwapchainStatusKHR(device, swapchain); + } + void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const { + _vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + } + VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const { + return _vkImportFenceFdKHR(device, pImportFenceFdInfo); + } + VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const { + return _vkGetFenceFdKHR(device, pGetFdInfo, pFd); + } + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const { + return _vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); + } + void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) const { + _vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); + } + VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) const { + return _vkAcquireProfilingLockKHR(device, pInfo); + } + void vkReleaseProfilingLockKHR(VkDevice device) const { + _vkReleaseProfilingLockKHR(device); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const { + return _vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); + } + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const { + return _vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); + } + VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) const { + return _vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); + } + VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) const { + return _vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); + } + void vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); + } + void vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); + } + void vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const { + return _vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); + } + void vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); + } + VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const { + return _vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos); + } + VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const { + return _vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos); + } + void vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const { + _vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); + } + void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) const { + return _vkGetSemaphoreCounterValueKHR(device, semaphore, pValue); + } + VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) const { + return _vkWaitSemaphoresKHR(device, pWaitInfo, timeout); + } + VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) const { + return _vkSignalSemaphoreKHR(device, pSignalInfo); + } + VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) const { + return _vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); + } + void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const { + _vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); + } + void vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo) const { + _vkCmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); + } + void vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo) const { + _vkCmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); + } + VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const { + return _vkWaitForPresentKHR(device, swapchain, presentId, timeout); + } + VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferDeviceAddressKHR(device, pInfo); + } + uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferOpaqueCaptureAddressKHR(device, pInfo); + } + uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const { + return _vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo); + } + VkResult vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) const { + return _vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation); + } + void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDeferredOperationKHR(device, operation, pAllocator); + } + uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) const { + return _vkGetDeferredOperationMaxConcurrencyKHR(device, operation); + } + VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) const { + return _vkGetDeferredOperationResultKHR(device, operation); + } + VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) const { + return _vkDeferredOperationJoinKHR(device, operation); + } + VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const { + return _vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); + } + VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const { + return _vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); + } + VkResult vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const { + return _vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + } + VkResult vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) const { + return _vkMapMemory2KHR(device, pMemoryMapInfo, ppData); + } + VkResult vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) const { + return _vkUnmapMemory2KHR(device, pMemoryUnmapInfo); + } + VkResult vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) const { + return _vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties); + } + VkResult vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) const { + return _vkGetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); + } + void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const { + _vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo); + } + void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); + } + void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const { + _vkCmdResetEvent2KHR(commandBuffer, event, stageMask); + } + void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) const { + _vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); + } + void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) const { + _vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); + } + void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const { + _vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); + } + VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) const { + return _vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence); + } + void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const { + _vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); + } + void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) const { + _vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); + } + void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) const { + _vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); + } + void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) const { + _vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo); + } + void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) const { + _vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); + } + void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) const { + _vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); + } + void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) const { + _vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo); + } + void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) const { + _vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo); + } + void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) const { + _vkCmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); + } + void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); + } + void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const { + _vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } + void vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) const { + _vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); + } + void vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) const { + _vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity); + } + void vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout) const { + _vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout); + } + void vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout) const { + _vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout); + } + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) const { + return _vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } + void vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const { + _vkCmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); + } + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) const { + return _vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); + } + VkResult vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const { + return _vkGetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + } + void vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) const { + _vkCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); + } + void vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo) const { + _vkCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); + } + void vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) const { + _vkCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); + } + void vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) const { + _vkCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); + } + void vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) const { + _vkCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); + } + void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) const { + _vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); + } + VkResult vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const { + return _vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); + } + void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator); + } + void vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) const { + _vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); + } + VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const { + return _vkDebugMarkerSetObjectTagEXT(device, pTagInfo); + } + VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const { + return _vkDebugMarkerSetObjectNameEXT(device, pNameInfo); + } + void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const { + _vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); + } + void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const { + _vkCmdDebugMarkerEndEXT(commandBuffer); + } + void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const { + _vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); + } + void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) const { + _vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + } + void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const { + _vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + } + void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const { + _vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + } + void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const { + _vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); + } + void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const { + _vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); + } + void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) const { + _vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + } + VkResult vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) const { + return _vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule); + } + VkResult vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) const { + return _vkCreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction); + } + void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCuModuleNVX(device, module, pAllocator); + } + void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCuFunctionNVX(device, function, pAllocator); + } + void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) const { + _vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); + } + uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) const { + return _vkGetImageViewHandleNVX(device, pInfo); + } + VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) const { + return _vkGetImageViewAddressNVX(device, imageView, pProperties); + } + void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) const { + return _vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + } + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const { + return _vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); + } + void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const { + _vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); + } + void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const { + _vkCmdEndConditionalRenderingEXT(commandBuffer); + } + void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) const { + _vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); + } + VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const { + return _vkReleaseDisplayEXT(physicalDevice, display); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) const { + return _vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); + } + VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const { + return _vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo); + } + VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const { + return _vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); + } + VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const { + return _vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); + } + VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) const { + return _vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); + } + VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const { + return _vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); + } + VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) const { + return _vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); + } + void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) const { + _vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); + } + void vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) const { + _vkCmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); + } + void vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) const { + _vkCmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); + } + void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) const { + _vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); + } + VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) const { + return _vkSetDebugUtilsObjectNameEXT(device, pNameInfo); + } + VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) const { + return _vkSetDebugUtilsObjectTagEXT(device, pTagInfo); + } + void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); + } + void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const { + _vkQueueEndDebugUtilsLabelEXT(queue); + } + void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); + } + void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + } + void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const { + _vkCmdEndDebugUtilsLabelEXT(commandBuffer); + } + void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const { + _vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + } + VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) const { + return _vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); + } + void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); + } + void vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) const { + _vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); + } + void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const { + _vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); + } + void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) const { + _vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); + } + VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) const { + return _vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); + } + VkResult vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) const { + return _vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); + } + void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyValidationCacheEXT(device, validationCache, pAllocator); + } + VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) const { + return _vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); + } + VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) const { + return _vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData); + } + void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const { + _vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); + } + void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) const { + _vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); + } + void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) const { + _vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); + } + VkResult vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) const { + return _vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); + } + void vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); + } + void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const { + _vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); + } + VkResult vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) const { + return _vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); + } + void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) const { + _vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); + } + void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) const { + _vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); + } + void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) const { + _vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); + } + VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const { + return _vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); + } + VkResult vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const { + return _vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); + } + VkResult vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) const { + return _vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); + } + void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const { + _vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + } + VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) const { + return _vkCompileDeferredNV(device, pipeline, shader); + } + VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) const { + return _vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); + } + void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const { + _vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); + } + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) const { + return _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); + } + VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const { + return _vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + } + void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const { + _vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); + } + void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + void vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) const { + _vkCmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); + } + void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) const { + _vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); + } + void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) const { + _vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); + } + void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) const { + _vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); + } + VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) const { + return _vkInitializePerformanceApiINTEL(device, pInitializeInfo); + } + void vkUninitializePerformanceApiINTEL(VkDevice device) const { + _vkUninitializePerformanceApiINTEL(device); + } + VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) const { + return _vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); + } + VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) const { + return _vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); + } + VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) const { + return _vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); + } + VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) const { + return _vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); + } + VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) const { + return _vkReleasePerformanceConfigurationINTEL(device, configuration); + } + VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) const { + return _vkQueueSetPerformanceConfigurationINTEL(queue, configuration); + } + VkResult vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) const { + return _vkGetPerformanceParameterINTEL(device, parameter, pValue); + } + void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const { + _vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable); + } + VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const { + return _vkGetBufferDeviceAddressEXT(device, pInfo); + } + VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) const { + return _vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties); + } + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) const { + return _vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) const { + return _vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); + } + VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { + return _vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); + } + void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const { + _vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); + } + void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const { + _vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); + } + void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const { + _vkCmdSetCullModeEXT(commandBuffer, cullMode); + } + void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const { + _vkCmdSetFrontFaceEXT(commandBuffer, frontFace); + } + void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const { + _vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); + } + void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const { + _vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); + } + void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const { + _vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); + } + void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const { + _vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + } + void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const { + _vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); + } + void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const { + _vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); + } + void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const { + _vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); + } + void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const { + _vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); + } + void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const { + _vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); + } + void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const { + _vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + } + VkResult vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) const { + return _vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo); + } + VkResult vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) const { + return _vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo); + } + VkResult vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) const { + return _vkCopyImageToImageEXT(device, pCopyImageToImageInfo); + } + VkResult vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT* pTransitions) const { + return _vkTransitionImageLayoutEXT(device, transitionCount, pTransitions); + } + void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout) const { + _vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); + } + VkResult vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) const { + return _vkReleaseSwapchainImagesEXT(device, pReleaseInfo); + } + void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements); + } + void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const { + _vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); + } + void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const { + _vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); + } + void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) const { + _vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); + } + VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) const { + return _vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + } + void vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); + } + void vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) const { + _vkCmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); + } + VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const { + return _vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display); + } + VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) const { + return _vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display); + } + VkResult vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) const { + return _vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot); + } + void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); + } + VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const { + return _vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); + } + void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) const { + _vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData); + } + VkResult vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) const { + return _vkCreateCudaModuleNV(device, pCreateInfo, pAllocator, pModule); + } + VkResult vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) const { + return _vkGetCudaModuleCacheNV(device, module, pCacheSize, pCacheData); + } + VkResult vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) const { + return _vkCreateCudaFunctionNV(device, pCreateInfo, pAllocator, pFunction); + } + void vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCudaModuleNV(device, module, pAllocator); + } + void vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyCudaFunctionNV(device, function, pAllocator); + } + void vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) const { + _vkCmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); + } + void vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) const { + _vkGetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes); + } + void vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) const { + _vkGetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset); + } + void vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) const { + _vkGetDescriptorEXT(device, pDescriptorInfo, dataSize, pDescriptor); + } + void vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) const { + _vkCmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); + } + void vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) const { + _vkCmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); + } + void vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) const { + _vkCmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); + } + VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + } + VkResult vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + } + VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + } + VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + } + VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) const { + return _vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + } + void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const { + _vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); + } + VkResult vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) const { + return _vkGetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo); + } + void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) const { + _vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); + } + VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) const { + return _vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize); + } + void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const { + _vkCmdSubpassShadingHUAWEI(commandBuffer); + } + void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const { + _vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); + } + VkResult vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) const { + return _vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress); + } + VkResult vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) const { + return _vkGetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); + } + void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const { + _vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); + } + void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const { + _vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); + } + void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const { + _vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); + } + void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const { + _vkCmdSetLogicOpEXT(commandBuffer, logicOp); + } + void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const { + _vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); + } + void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) const { + _vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); + } + void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) const { + _vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); + } + void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) const { + _vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); + } + VkResult vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) const { + return _vkCreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap); + } + void vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyMicromapEXT(device, micromap, pAllocator); + } + void vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) const { + _vkCmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); + } + VkResult vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) const { + return _vkBuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); + } + VkResult vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) const { + return _vkCopyMicromapEXT(device, deferredOperation, pInfo); + } + VkResult vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) const { + return _vkCopyMicromapToMemoryEXT(device, deferredOperation, pInfo); + } + VkResult vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) const { + return _vkCopyMemoryToMicromapEXT(device, deferredOperation, pInfo); + } + VkResult vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) const { + return _vkWriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); + } + void vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) const { + _vkCmdCopyMicromapEXT(commandBuffer, pInfo); + } + void vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) const { + _vkCmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); + } + void vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) const { + _vkCmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); + } + void vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const { + _vkCmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); + } + void vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) const { + _vkGetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility); + } + void vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) const { + _vkGetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo); + } + void vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const { + _vkCmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); + } + void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) const { + _vkSetDeviceMemoryPriorityEXT(device, memory, priority); + } + void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) const { + _vkGetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); + } + void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) const { + _vkGetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); + } + void vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) const { + _vkCmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); + } + void vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) const { + _vkCmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); + } + void vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) const { + _vkCmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); + } + void vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) const { + _vkCmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); + } + void vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) const { + _vkGetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, pMemoryRequirements); + } + void vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const { + _vkCmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); + } + VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) const { + return _vkGetPipelineIndirectDeviceAddressNV(device, pInfo); + } + void vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) const { + _vkCmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); + } + void vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) const { + _vkCmdSetPolygonModeEXT(commandBuffer, polygonMode); + } + void vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) const { + _vkCmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); + } + void vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) const { + _vkCmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); + } + void vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) const { + _vkCmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); + } + void vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) const { + _vkCmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); + } + void vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) const { + _vkCmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); + } + void vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) const { + _vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); + } + void vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) const { + _vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); + } + void vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) const { + _vkCmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); + } + void vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) const { + _vkCmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); + } + void vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) const { + _vkCmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); + } + void vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) const { + _vkCmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); + } + void vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) const { + _vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); + } + void vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) const { + _vkCmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); + } + void vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) const { + _vkCmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); + } + void vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) const { + _vkCmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); + } + void vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) const { + _vkCmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); + } + void vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) const { + _vkCmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); + } + void vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) const { + _vkCmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); + } + void vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) const { + _vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); + } + void vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) const { + _vkCmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); + } + void vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) const { + _vkCmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); + } + void vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) const { + _vkCmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); + } + void vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) const { + _vkCmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); + } + void vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) const { + _vkCmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); + } + void vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) const { + _vkCmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); + } + void vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) const { + _vkCmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); + } + void vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) const { + _vkCmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); + } + void vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) const { + _vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); + } + void vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) const { + _vkCmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); + } + void vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) const { + _vkGetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); + } + void vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) const { + _vkGetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); + } + VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) const { + return _vkGetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); + } + VkResult vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) const { + return _vkCreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession); + } + void vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyOpticalFlowSessionNV(device, session, pAllocator); + } + VkResult vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) const { + return _vkBindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); + } + void vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) const { + _vkCmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); + } + VkResult vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) const { + return _vkCreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, pShaders); + } + void vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyShaderEXT(device, shader, pAllocator); + } + VkResult vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) const { + return _vkGetShaderBinaryDataEXT(device, shader, pDataSize, pData); + } + void vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) const { + _vkCmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); + } + VkResult vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) const { + return _vkGetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); + } + VkResult vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const { + return _vkGetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); + } + VkResult vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) const { + return _vkSetLatencySleepModeNV(device, swapchain, pSleepModeInfo); + } + VkResult vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) const { + return _vkLatencySleepNV(device, swapchain, pSleepInfo); + } + void vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) const { + _vkSetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo); + } + void vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) const { + _vkGetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo); + } + void vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) const { + _vkQueueNotifyOutOfBandNV(queue, pQueueTypeInfo); + } + void vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) const { + _vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); + } + VkResult vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const { + return _vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); + } + void vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); + } + void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const { + _vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); + } + void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) const { + _vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); + } + VkResult vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const { + return _vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + } + VkResult vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) const { + return _vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo); + } + VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const { + return _vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); + } + VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const { + return _vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); + } + VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) const { + return _vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + } + void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) const { + _vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo); + } + void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const { + _vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); + } + void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const { + _vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); + } + VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) const { + return _vkGetAccelerationStructureDeviceAddressKHR(device, pInfo); + } + void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const { + _vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + } + void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) const { + _vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); + } + void vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) const { + _vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); + } + void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) const { + _vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); + } + VkResult vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const { + return _vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const { + return _vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); + } + void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) const { + _vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); + } + VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) const { + return _vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); + } + void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const { + _vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); + } + void vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const { + _vkCmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); + } + void vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); + } + void vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const { + _vkCmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } + +private: + PFN_vkCreateInstance _vkCreateInstance; + PFN_vkDestroyInstance _vkDestroyInstance; + PFN_vkEnumeratePhysicalDevices _vkEnumeratePhysicalDevices; + PFN_vkGetPhysicalDeviceFeatures _vkGetPhysicalDeviceFeatures; + PFN_vkGetPhysicalDeviceFormatProperties _vkGetPhysicalDeviceFormatProperties; + PFN_vkGetPhysicalDeviceImageFormatProperties _vkGetPhysicalDeviceImageFormatProperties; + PFN_vkGetPhysicalDeviceProperties _vkGetPhysicalDeviceProperties; + PFN_vkGetPhysicalDeviceQueueFamilyProperties _vkGetPhysicalDeviceQueueFamilyProperties; + PFN_vkGetPhysicalDeviceMemoryProperties _vkGetPhysicalDeviceMemoryProperties; + PFN_vkGetInstanceProcAddr _vkGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr _vkGetDeviceProcAddr; + PFN_vkCreateDevice _vkCreateDevice; + PFN_vkDestroyDevice _vkDestroyDevice; + PFN_vkEnumerateInstanceExtensionProperties _vkEnumerateInstanceExtensionProperties; + PFN_vkEnumerateDeviceExtensionProperties _vkEnumerateDeviceExtensionProperties; + PFN_vkEnumerateInstanceLayerProperties _vkEnumerateInstanceLayerProperties; + PFN_vkEnumerateDeviceLayerProperties _vkEnumerateDeviceLayerProperties; + PFN_vkGetDeviceQueue _vkGetDeviceQueue; + PFN_vkQueueSubmit _vkQueueSubmit; + PFN_vkQueueWaitIdle _vkQueueWaitIdle; + PFN_vkDeviceWaitIdle _vkDeviceWaitIdle; + PFN_vkAllocateMemory _vkAllocateMemory; + PFN_vkFreeMemory _vkFreeMemory; + PFN_vkMapMemory _vkMapMemory; + PFN_vkUnmapMemory _vkUnmapMemory; + PFN_vkFlushMappedMemoryRanges _vkFlushMappedMemoryRanges; + PFN_vkInvalidateMappedMemoryRanges _vkInvalidateMappedMemoryRanges; + PFN_vkGetDeviceMemoryCommitment _vkGetDeviceMemoryCommitment; + PFN_vkBindBufferMemory _vkBindBufferMemory; + PFN_vkBindImageMemory _vkBindImageMemory; + PFN_vkGetBufferMemoryRequirements _vkGetBufferMemoryRequirements; + PFN_vkGetImageMemoryRequirements _vkGetImageMemoryRequirements; + PFN_vkGetImageSparseMemoryRequirements _vkGetImageSparseMemoryRequirements; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties _vkGetPhysicalDeviceSparseImageFormatProperties; + PFN_vkQueueBindSparse _vkQueueBindSparse; + PFN_vkCreateFence _vkCreateFence; + PFN_vkDestroyFence _vkDestroyFence; + PFN_vkResetFences _vkResetFences; + PFN_vkGetFenceStatus _vkGetFenceStatus; + PFN_vkWaitForFences _vkWaitForFences; + PFN_vkCreateSemaphore _vkCreateSemaphore; + PFN_vkDestroySemaphore _vkDestroySemaphore; + PFN_vkCreateEvent _vkCreateEvent; + PFN_vkDestroyEvent _vkDestroyEvent; + PFN_vkGetEventStatus _vkGetEventStatus; + PFN_vkSetEvent _vkSetEvent; + PFN_vkResetEvent _vkResetEvent; + PFN_vkCreateQueryPool _vkCreateQueryPool; + PFN_vkDestroyQueryPool _vkDestroyQueryPool; + PFN_vkGetQueryPoolResults _vkGetQueryPoolResults; + PFN_vkCreateBuffer _vkCreateBuffer; + PFN_vkDestroyBuffer _vkDestroyBuffer; + PFN_vkCreateBufferView _vkCreateBufferView; + PFN_vkDestroyBufferView _vkDestroyBufferView; + PFN_vkCreateImage _vkCreateImage; + PFN_vkDestroyImage _vkDestroyImage; + PFN_vkGetImageSubresourceLayout _vkGetImageSubresourceLayout; + PFN_vkCreateImageView _vkCreateImageView; + PFN_vkDestroyImageView _vkDestroyImageView; + PFN_vkCreateShaderModule _vkCreateShaderModule; + PFN_vkDestroyShaderModule _vkDestroyShaderModule; + PFN_vkCreatePipelineCache _vkCreatePipelineCache; + PFN_vkDestroyPipelineCache _vkDestroyPipelineCache; + PFN_vkGetPipelineCacheData _vkGetPipelineCacheData; + PFN_vkMergePipelineCaches _vkMergePipelineCaches; + PFN_vkCreateGraphicsPipelines _vkCreateGraphicsPipelines; + PFN_vkCreateComputePipelines _vkCreateComputePipelines; + PFN_vkDestroyPipeline _vkDestroyPipeline; + PFN_vkCreatePipelineLayout _vkCreatePipelineLayout; + PFN_vkDestroyPipelineLayout _vkDestroyPipelineLayout; + PFN_vkCreateSampler _vkCreateSampler; + PFN_vkDestroySampler _vkDestroySampler; + PFN_vkCreateDescriptorSetLayout _vkCreateDescriptorSetLayout; + PFN_vkDestroyDescriptorSetLayout _vkDestroyDescriptorSetLayout; + PFN_vkCreateDescriptorPool _vkCreateDescriptorPool; + PFN_vkDestroyDescriptorPool _vkDestroyDescriptorPool; + PFN_vkResetDescriptorPool _vkResetDescriptorPool; + PFN_vkAllocateDescriptorSets _vkAllocateDescriptorSets; + PFN_vkFreeDescriptorSets _vkFreeDescriptorSets; + PFN_vkUpdateDescriptorSets _vkUpdateDescriptorSets; + PFN_vkCreateFramebuffer _vkCreateFramebuffer; + PFN_vkDestroyFramebuffer _vkDestroyFramebuffer; + PFN_vkCreateRenderPass _vkCreateRenderPass; + PFN_vkDestroyRenderPass _vkDestroyRenderPass; + PFN_vkGetRenderAreaGranularity _vkGetRenderAreaGranularity; + PFN_vkCreateCommandPool _vkCreateCommandPool; + PFN_vkDestroyCommandPool _vkDestroyCommandPool; + PFN_vkResetCommandPool _vkResetCommandPool; + PFN_vkAllocateCommandBuffers _vkAllocateCommandBuffers; + PFN_vkFreeCommandBuffers _vkFreeCommandBuffers; + PFN_vkBeginCommandBuffer _vkBeginCommandBuffer; + PFN_vkEndCommandBuffer _vkEndCommandBuffer; + PFN_vkResetCommandBuffer _vkResetCommandBuffer; + PFN_vkCmdBindPipeline _vkCmdBindPipeline; + PFN_vkCmdSetViewport _vkCmdSetViewport; + PFN_vkCmdSetScissor _vkCmdSetScissor; + PFN_vkCmdSetLineWidth _vkCmdSetLineWidth; + PFN_vkCmdSetDepthBias _vkCmdSetDepthBias; + PFN_vkCmdSetBlendConstants _vkCmdSetBlendConstants; + PFN_vkCmdSetDepthBounds _vkCmdSetDepthBounds; + PFN_vkCmdSetStencilCompareMask _vkCmdSetStencilCompareMask; + PFN_vkCmdSetStencilWriteMask _vkCmdSetStencilWriteMask; + PFN_vkCmdSetStencilReference _vkCmdSetStencilReference; + PFN_vkCmdBindDescriptorSets _vkCmdBindDescriptorSets; + PFN_vkCmdBindIndexBuffer _vkCmdBindIndexBuffer; + PFN_vkCmdBindVertexBuffers _vkCmdBindVertexBuffers; + PFN_vkCmdDraw _vkCmdDraw; + PFN_vkCmdDrawIndexed _vkCmdDrawIndexed; + PFN_vkCmdDrawIndirect _vkCmdDrawIndirect; + PFN_vkCmdDrawIndexedIndirect _vkCmdDrawIndexedIndirect; + PFN_vkCmdDispatch _vkCmdDispatch; + PFN_vkCmdDispatchIndirect _vkCmdDispatchIndirect; + PFN_vkCmdCopyBuffer _vkCmdCopyBuffer; + PFN_vkCmdCopyImage _vkCmdCopyImage; + PFN_vkCmdBlitImage _vkCmdBlitImage; + PFN_vkCmdCopyBufferToImage _vkCmdCopyBufferToImage; + PFN_vkCmdCopyImageToBuffer _vkCmdCopyImageToBuffer; + PFN_vkCmdUpdateBuffer _vkCmdUpdateBuffer; + PFN_vkCmdFillBuffer _vkCmdFillBuffer; + PFN_vkCmdClearColorImage _vkCmdClearColorImage; + PFN_vkCmdClearDepthStencilImage _vkCmdClearDepthStencilImage; + PFN_vkCmdClearAttachments _vkCmdClearAttachments; + PFN_vkCmdResolveImage _vkCmdResolveImage; + PFN_vkCmdSetEvent _vkCmdSetEvent; + PFN_vkCmdResetEvent _vkCmdResetEvent; + PFN_vkCmdWaitEvents _vkCmdWaitEvents; + PFN_vkCmdPipelineBarrier _vkCmdPipelineBarrier; + PFN_vkCmdBeginQuery _vkCmdBeginQuery; + PFN_vkCmdEndQuery _vkCmdEndQuery; + PFN_vkCmdResetQueryPool _vkCmdResetQueryPool; + PFN_vkCmdWriteTimestamp _vkCmdWriteTimestamp; + PFN_vkCmdCopyQueryPoolResults _vkCmdCopyQueryPoolResults; + PFN_vkCmdPushConstants _vkCmdPushConstants; + PFN_vkCmdBeginRenderPass _vkCmdBeginRenderPass; + PFN_vkCmdNextSubpass _vkCmdNextSubpass; + PFN_vkCmdEndRenderPass _vkCmdEndRenderPass; + PFN_vkCmdExecuteCommands _vkCmdExecuteCommands; + PFN_vkEnumerateInstanceVersion _vkEnumerateInstanceVersion; + PFN_vkBindBufferMemory2 _vkBindBufferMemory2; + PFN_vkBindImageMemory2 _vkBindImageMemory2; + PFN_vkGetDeviceGroupPeerMemoryFeatures _vkGetDeviceGroupPeerMemoryFeatures; + PFN_vkCmdSetDeviceMask _vkCmdSetDeviceMask; + PFN_vkCmdDispatchBase _vkCmdDispatchBase; + PFN_vkEnumeratePhysicalDeviceGroups _vkEnumeratePhysicalDeviceGroups; + PFN_vkGetImageMemoryRequirements2 _vkGetImageMemoryRequirements2; + PFN_vkGetBufferMemoryRequirements2 _vkGetBufferMemoryRequirements2; + PFN_vkGetImageSparseMemoryRequirements2 _vkGetImageSparseMemoryRequirements2; + PFN_vkGetPhysicalDeviceFeatures2 _vkGetPhysicalDeviceFeatures2; + PFN_vkGetPhysicalDeviceProperties2 _vkGetPhysicalDeviceProperties2; + PFN_vkGetPhysicalDeviceFormatProperties2 _vkGetPhysicalDeviceFormatProperties2; + PFN_vkGetPhysicalDeviceImageFormatProperties2 _vkGetPhysicalDeviceImageFormatProperties2; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 _vkGetPhysicalDeviceQueueFamilyProperties2; + PFN_vkGetPhysicalDeviceMemoryProperties2 _vkGetPhysicalDeviceMemoryProperties2; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 _vkGetPhysicalDeviceSparseImageFormatProperties2; + PFN_vkTrimCommandPool _vkTrimCommandPool; + PFN_vkGetDeviceQueue2 _vkGetDeviceQueue2; + PFN_vkCreateSamplerYcbcrConversion _vkCreateSamplerYcbcrConversion; + PFN_vkDestroySamplerYcbcrConversion _vkDestroySamplerYcbcrConversion; + PFN_vkCreateDescriptorUpdateTemplate _vkCreateDescriptorUpdateTemplate; + PFN_vkDestroyDescriptorUpdateTemplate _vkDestroyDescriptorUpdateTemplate; + PFN_vkUpdateDescriptorSetWithTemplate _vkUpdateDescriptorSetWithTemplate; + PFN_vkGetPhysicalDeviceExternalBufferProperties _vkGetPhysicalDeviceExternalBufferProperties; + PFN_vkGetPhysicalDeviceExternalFenceProperties _vkGetPhysicalDeviceExternalFenceProperties; + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties _vkGetPhysicalDeviceExternalSemaphoreProperties; + PFN_vkGetDescriptorSetLayoutSupport _vkGetDescriptorSetLayoutSupport; + PFN_vkCmdDrawIndirectCount _vkCmdDrawIndirectCount; + PFN_vkCmdDrawIndexedIndirectCount _vkCmdDrawIndexedIndirectCount; + PFN_vkCreateRenderPass2 _vkCreateRenderPass2; + PFN_vkCmdBeginRenderPass2 _vkCmdBeginRenderPass2; + PFN_vkCmdNextSubpass2 _vkCmdNextSubpass2; + PFN_vkCmdEndRenderPass2 _vkCmdEndRenderPass2; + PFN_vkResetQueryPool _vkResetQueryPool; + PFN_vkGetSemaphoreCounterValue _vkGetSemaphoreCounterValue; + PFN_vkWaitSemaphores _vkWaitSemaphores; + PFN_vkSignalSemaphore _vkSignalSemaphore; + PFN_vkGetBufferDeviceAddress _vkGetBufferDeviceAddress; + PFN_vkGetBufferOpaqueCaptureAddress _vkGetBufferOpaqueCaptureAddress; + PFN_vkGetDeviceMemoryOpaqueCaptureAddress _vkGetDeviceMemoryOpaqueCaptureAddress; + PFN_vkGetPhysicalDeviceToolProperties _vkGetPhysicalDeviceToolProperties; + PFN_vkCreatePrivateDataSlot _vkCreatePrivateDataSlot; + PFN_vkDestroyPrivateDataSlot _vkDestroyPrivateDataSlot; + PFN_vkSetPrivateData _vkSetPrivateData; + PFN_vkGetPrivateData _vkGetPrivateData; + PFN_vkCmdSetEvent2 _vkCmdSetEvent2; + PFN_vkCmdResetEvent2 _vkCmdResetEvent2; + PFN_vkCmdWaitEvents2 _vkCmdWaitEvents2; + PFN_vkCmdPipelineBarrier2 _vkCmdPipelineBarrier2; + PFN_vkCmdWriteTimestamp2 _vkCmdWriteTimestamp2; + PFN_vkQueueSubmit2 _vkQueueSubmit2; + PFN_vkCmdCopyBuffer2 _vkCmdCopyBuffer2; + PFN_vkCmdCopyImage2 _vkCmdCopyImage2; + PFN_vkCmdCopyBufferToImage2 _vkCmdCopyBufferToImage2; + PFN_vkCmdCopyImageToBuffer2 _vkCmdCopyImageToBuffer2; + PFN_vkCmdBlitImage2 _vkCmdBlitImage2; + PFN_vkCmdResolveImage2 _vkCmdResolveImage2; + PFN_vkCmdBeginRendering _vkCmdBeginRendering; + PFN_vkCmdEndRendering _vkCmdEndRendering; + PFN_vkCmdSetCullMode _vkCmdSetCullMode; + PFN_vkCmdSetFrontFace _vkCmdSetFrontFace; + PFN_vkCmdSetPrimitiveTopology _vkCmdSetPrimitiveTopology; + PFN_vkCmdSetViewportWithCount _vkCmdSetViewportWithCount; + PFN_vkCmdSetScissorWithCount _vkCmdSetScissorWithCount; + PFN_vkCmdBindVertexBuffers2 _vkCmdBindVertexBuffers2; + PFN_vkCmdSetDepthTestEnable _vkCmdSetDepthTestEnable; + PFN_vkCmdSetDepthWriteEnable _vkCmdSetDepthWriteEnable; + PFN_vkCmdSetDepthCompareOp _vkCmdSetDepthCompareOp; + PFN_vkCmdSetDepthBoundsTestEnable _vkCmdSetDepthBoundsTestEnable; + PFN_vkCmdSetStencilTestEnable _vkCmdSetStencilTestEnable; + PFN_vkCmdSetStencilOp _vkCmdSetStencilOp; + PFN_vkCmdSetRasterizerDiscardEnable _vkCmdSetRasterizerDiscardEnable; + PFN_vkCmdSetDepthBiasEnable _vkCmdSetDepthBiasEnable; + PFN_vkCmdSetPrimitiveRestartEnable _vkCmdSetPrimitiveRestartEnable; + PFN_vkGetDeviceBufferMemoryRequirements _vkGetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceImageMemoryRequirements _vkGetDeviceImageMemoryRequirements; + PFN_vkGetDeviceImageSparseMemoryRequirements _vkGetDeviceImageSparseMemoryRequirements; + PFN_vkDestroySurfaceKHR _vkDestroySurfaceKHR; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR _vkGetPhysicalDeviceSurfaceSupportKHR; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR _vkGetPhysicalDeviceSurfaceCapabilitiesKHR; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR _vkGetPhysicalDeviceSurfaceFormatsKHR; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR _vkGetPhysicalDeviceSurfacePresentModesKHR; + PFN_vkCreateSwapchainKHR _vkCreateSwapchainKHR; + PFN_vkDestroySwapchainKHR _vkDestroySwapchainKHR; + PFN_vkGetSwapchainImagesKHR _vkGetSwapchainImagesKHR; + PFN_vkAcquireNextImageKHR _vkAcquireNextImageKHR; + PFN_vkQueuePresentKHR _vkQueuePresentKHR; + PFN_vkGetDeviceGroupPresentCapabilitiesKHR _vkGetDeviceGroupPresentCapabilitiesKHR; + PFN_vkGetDeviceGroupSurfacePresentModesKHR _vkGetDeviceGroupSurfacePresentModesKHR; + PFN_vkGetPhysicalDevicePresentRectanglesKHR _vkGetPhysicalDevicePresentRectanglesKHR; + PFN_vkAcquireNextImage2KHR _vkAcquireNextImage2KHR; + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR _vkGetPhysicalDeviceDisplayPropertiesKHR; + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR _vkGetPhysicalDeviceDisplayPlanePropertiesKHR; + PFN_vkGetDisplayPlaneSupportedDisplaysKHR _vkGetDisplayPlaneSupportedDisplaysKHR; + PFN_vkGetDisplayModePropertiesKHR _vkGetDisplayModePropertiesKHR; + PFN_vkCreateDisplayModeKHR _vkCreateDisplayModeKHR; + PFN_vkGetDisplayPlaneCapabilitiesKHR _vkGetDisplayPlaneCapabilitiesKHR; + PFN_vkCreateDisplayPlaneSurfaceKHR _vkCreateDisplayPlaneSurfaceKHR; + PFN_vkCreateSharedSwapchainsKHR _vkCreateSharedSwapchainsKHR; + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR _vkGetPhysicalDeviceVideoCapabilitiesKHR; + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR _vkGetPhysicalDeviceVideoFormatPropertiesKHR; + PFN_vkCreateVideoSessionKHR _vkCreateVideoSessionKHR; + PFN_vkDestroyVideoSessionKHR _vkDestroyVideoSessionKHR; + PFN_vkGetVideoSessionMemoryRequirementsKHR _vkGetVideoSessionMemoryRequirementsKHR; + PFN_vkBindVideoSessionMemoryKHR _vkBindVideoSessionMemoryKHR; + PFN_vkCreateVideoSessionParametersKHR _vkCreateVideoSessionParametersKHR; + PFN_vkUpdateVideoSessionParametersKHR _vkUpdateVideoSessionParametersKHR; + PFN_vkDestroyVideoSessionParametersKHR _vkDestroyVideoSessionParametersKHR; + PFN_vkCmdBeginVideoCodingKHR _vkCmdBeginVideoCodingKHR; + PFN_vkCmdEndVideoCodingKHR _vkCmdEndVideoCodingKHR; + PFN_vkCmdControlVideoCodingKHR _vkCmdControlVideoCodingKHR; + PFN_vkCmdDecodeVideoKHR _vkCmdDecodeVideoKHR; + PFN_vkCmdBeginRenderingKHR _vkCmdBeginRenderingKHR; + PFN_vkCmdEndRenderingKHR _vkCmdEndRenderingKHR; + PFN_vkGetPhysicalDeviceFeatures2KHR _vkGetPhysicalDeviceFeatures2KHR; + PFN_vkGetPhysicalDeviceProperties2KHR _vkGetPhysicalDeviceProperties2KHR; + PFN_vkGetPhysicalDeviceFormatProperties2KHR _vkGetPhysicalDeviceFormatProperties2KHR; + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR _vkGetPhysicalDeviceImageFormatProperties2KHR; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR _vkGetPhysicalDeviceQueueFamilyProperties2KHR; + PFN_vkGetPhysicalDeviceMemoryProperties2KHR _vkGetPhysicalDeviceMemoryProperties2KHR; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR _vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR _vkGetDeviceGroupPeerMemoryFeaturesKHR; + PFN_vkCmdSetDeviceMaskKHR _vkCmdSetDeviceMaskKHR; + PFN_vkCmdDispatchBaseKHR _vkCmdDispatchBaseKHR; + PFN_vkTrimCommandPoolKHR _vkTrimCommandPoolKHR; + PFN_vkEnumeratePhysicalDeviceGroupsKHR _vkEnumeratePhysicalDeviceGroupsKHR; + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR _vkGetPhysicalDeviceExternalBufferPropertiesKHR; + PFN_vkGetMemoryFdKHR _vkGetMemoryFdKHR; + PFN_vkGetMemoryFdPropertiesKHR _vkGetMemoryFdPropertiesKHR; + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR _vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + PFN_vkImportSemaphoreFdKHR _vkImportSemaphoreFdKHR; + PFN_vkGetSemaphoreFdKHR _vkGetSemaphoreFdKHR; + PFN_vkCmdPushDescriptorSetKHR _vkCmdPushDescriptorSetKHR; + PFN_vkCmdPushDescriptorSetWithTemplateKHR _vkCmdPushDescriptorSetWithTemplateKHR; + PFN_vkCreateDescriptorUpdateTemplateKHR _vkCreateDescriptorUpdateTemplateKHR; + PFN_vkDestroyDescriptorUpdateTemplateKHR _vkDestroyDescriptorUpdateTemplateKHR; + PFN_vkUpdateDescriptorSetWithTemplateKHR _vkUpdateDescriptorSetWithTemplateKHR; + PFN_vkCreateRenderPass2KHR _vkCreateRenderPass2KHR; + PFN_vkCmdBeginRenderPass2KHR _vkCmdBeginRenderPass2KHR; + PFN_vkCmdNextSubpass2KHR _vkCmdNextSubpass2KHR; + PFN_vkCmdEndRenderPass2KHR _vkCmdEndRenderPass2KHR; + PFN_vkGetSwapchainStatusKHR _vkGetSwapchainStatusKHR; + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR _vkGetPhysicalDeviceExternalFencePropertiesKHR; + PFN_vkImportFenceFdKHR _vkImportFenceFdKHR; + PFN_vkGetFenceFdKHR _vkGetFenceFdKHR; + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR _vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR _vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; + PFN_vkAcquireProfilingLockKHR _vkAcquireProfilingLockKHR; + PFN_vkReleaseProfilingLockKHR _vkReleaseProfilingLockKHR; + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR _vkGetPhysicalDeviceSurfaceCapabilities2KHR; + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR _vkGetPhysicalDeviceSurfaceFormats2KHR; + PFN_vkGetPhysicalDeviceDisplayProperties2KHR _vkGetPhysicalDeviceDisplayProperties2KHR; + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR _vkGetPhysicalDeviceDisplayPlaneProperties2KHR; + PFN_vkGetDisplayModeProperties2KHR _vkGetDisplayModeProperties2KHR; + PFN_vkGetDisplayPlaneCapabilities2KHR _vkGetDisplayPlaneCapabilities2KHR; + PFN_vkGetImageMemoryRequirements2KHR _vkGetImageMemoryRequirements2KHR; + PFN_vkGetBufferMemoryRequirements2KHR _vkGetBufferMemoryRequirements2KHR; + PFN_vkGetImageSparseMemoryRequirements2KHR _vkGetImageSparseMemoryRequirements2KHR; + PFN_vkCreateSamplerYcbcrConversionKHR _vkCreateSamplerYcbcrConversionKHR; + PFN_vkDestroySamplerYcbcrConversionKHR _vkDestroySamplerYcbcrConversionKHR; + PFN_vkBindBufferMemory2KHR _vkBindBufferMemory2KHR; + PFN_vkBindImageMemory2KHR _vkBindImageMemory2KHR; + PFN_vkGetDescriptorSetLayoutSupportKHR _vkGetDescriptorSetLayoutSupportKHR; + PFN_vkCmdDrawIndirectCountKHR _vkCmdDrawIndirectCountKHR; + PFN_vkCmdDrawIndexedIndirectCountKHR _vkCmdDrawIndexedIndirectCountKHR; + PFN_vkGetSemaphoreCounterValueKHR _vkGetSemaphoreCounterValueKHR; + PFN_vkWaitSemaphoresKHR _vkWaitSemaphoresKHR; + PFN_vkSignalSemaphoreKHR _vkSignalSemaphoreKHR; + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR _vkGetPhysicalDeviceFragmentShadingRatesKHR; + PFN_vkCmdSetFragmentShadingRateKHR _vkCmdSetFragmentShadingRateKHR; + PFN_vkCmdSetRenderingAttachmentLocationsKHR _vkCmdSetRenderingAttachmentLocationsKHR; + PFN_vkCmdSetRenderingInputAttachmentIndicesKHR _vkCmdSetRenderingInputAttachmentIndicesKHR; + PFN_vkWaitForPresentKHR _vkWaitForPresentKHR; + PFN_vkGetBufferDeviceAddressKHR _vkGetBufferDeviceAddressKHR; + PFN_vkGetBufferOpaqueCaptureAddressKHR _vkGetBufferOpaqueCaptureAddressKHR; + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR _vkGetDeviceMemoryOpaqueCaptureAddressKHR; + PFN_vkCreateDeferredOperationKHR _vkCreateDeferredOperationKHR; + PFN_vkDestroyDeferredOperationKHR _vkDestroyDeferredOperationKHR; + PFN_vkGetDeferredOperationMaxConcurrencyKHR _vkGetDeferredOperationMaxConcurrencyKHR; + PFN_vkGetDeferredOperationResultKHR _vkGetDeferredOperationResultKHR; + PFN_vkDeferredOperationJoinKHR _vkDeferredOperationJoinKHR; + PFN_vkGetPipelineExecutablePropertiesKHR _vkGetPipelineExecutablePropertiesKHR; + PFN_vkGetPipelineExecutableStatisticsKHR _vkGetPipelineExecutableStatisticsKHR; + PFN_vkGetPipelineExecutableInternalRepresentationsKHR _vkGetPipelineExecutableInternalRepresentationsKHR; + PFN_vkMapMemory2KHR _vkMapMemory2KHR; + PFN_vkUnmapMemory2KHR _vkUnmapMemory2KHR; + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR _vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; + PFN_vkGetEncodedVideoSessionParametersKHR _vkGetEncodedVideoSessionParametersKHR; + PFN_vkCmdEncodeVideoKHR _vkCmdEncodeVideoKHR; + PFN_vkCmdSetEvent2KHR _vkCmdSetEvent2KHR; + PFN_vkCmdResetEvent2KHR _vkCmdResetEvent2KHR; + PFN_vkCmdWaitEvents2KHR _vkCmdWaitEvents2KHR; + PFN_vkCmdPipelineBarrier2KHR _vkCmdPipelineBarrier2KHR; + PFN_vkCmdWriteTimestamp2KHR _vkCmdWriteTimestamp2KHR; + PFN_vkQueueSubmit2KHR _vkQueueSubmit2KHR; + PFN_vkCmdWriteBufferMarker2AMD _vkCmdWriteBufferMarker2AMD; + PFN_vkGetQueueCheckpointData2NV _vkGetQueueCheckpointData2NV; + PFN_vkCmdCopyBuffer2KHR _vkCmdCopyBuffer2KHR; + PFN_vkCmdCopyImage2KHR _vkCmdCopyImage2KHR; + PFN_vkCmdCopyBufferToImage2KHR _vkCmdCopyBufferToImage2KHR; + PFN_vkCmdCopyImageToBuffer2KHR _vkCmdCopyImageToBuffer2KHR; + PFN_vkCmdBlitImage2KHR _vkCmdBlitImage2KHR; + PFN_vkCmdResolveImage2KHR _vkCmdResolveImage2KHR; + PFN_vkCmdTraceRaysIndirect2KHR _vkCmdTraceRaysIndirect2KHR; + PFN_vkGetDeviceBufferMemoryRequirementsKHR _vkGetDeviceBufferMemoryRequirementsKHR; + PFN_vkGetDeviceImageMemoryRequirementsKHR _vkGetDeviceImageMemoryRequirementsKHR; + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR _vkGetDeviceImageSparseMemoryRequirementsKHR; + PFN_vkCmdBindIndexBuffer2KHR _vkCmdBindIndexBuffer2KHR; + PFN_vkGetRenderingAreaGranularityKHR _vkGetRenderingAreaGranularityKHR; + PFN_vkGetDeviceImageSubresourceLayoutKHR _vkGetDeviceImageSubresourceLayoutKHR; + PFN_vkGetImageSubresourceLayout2KHR _vkGetImageSubresourceLayout2KHR; + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR _vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; + PFN_vkCmdSetLineStippleKHR _vkCmdSetLineStippleKHR; + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR _vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; + PFN_vkGetCalibratedTimestampsKHR _vkGetCalibratedTimestampsKHR; + PFN_vkCmdBindDescriptorSets2KHR _vkCmdBindDescriptorSets2KHR; + PFN_vkCmdPushConstants2KHR _vkCmdPushConstants2KHR; + PFN_vkCmdPushDescriptorSet2KHR _vkCmdPushDescriptorSet2KHR; + PFN_vkCmdPushDescriptorSetWithTemplate2KHR _vkCmdPushDescriptorSetWithTemplate2KHR; + PFN_vkCmdSetDescriptorBufferOffsets2EXT _vkCmdSetDescriptorBufferOffsets2EXT; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT _vkCmdBindDescriptorBufferEmbeddedSamplers2EXT; + PFN_vkCreateDebugReportCallbackEXT _vkCreateDebugReportCallbackEXT; + PFN_vkDestroyDebugReportCallbackEXT _vkDestroyDebugReportCallbackEXT; + PFN_vkDebugReportMessageEXT _vkDebugReportMessageEXT; + PFN_vkDebugMarkerSetObjectTagEXT _vkDebugMarkerSetObjectTagEXT; + PFN_vkDebugMarkerSetObjectNameEXT _vkDebugMarkerSetObjectNameEXT; + PFN_vkCmdDebugMarkerBeginEXT _vkCmdDebugMarkerBeginEXT; + PFN_vkCmdDebugMarkerEndEXT _vkCmdDebugMarkerEndEXT; + PFN_vkCmdDebugMarkerInsertEXT _vkCmdDebugMarkerInsertEXT; + PFN_vkCmdBindTransformFeedbackBuffersEXT _vkCmdBindTransformFeedbackBuffersEXT; + PFN_vkCmdBeginTransformFeedbackEXT _vkCmdBeginTransformFeedbackEXT; + PFN_vkCmdEndTransformFeedbackEXT _vkCmdEndTransformFeedbackEXT; + PFN_vkCmdBeginQueryIndexedEXT _vkCmdBeginQueryIndexedEXT; + PFN_vkCmdEndQueryIndexedEXT _vkCmdEndQueryIndexedEXT; + PFN_vkCmdDrawIndirectByteCountEXT _vkCmdDrawIndirectByteCountEXT; + PFN_vkCreateCuModuleNVX _vkCreateCuModuleNVX; + PFN_vkCreateCuFunctionNVX _vkCreateCuFunctionNVX; + PFN_vkDestroyCuModuleNVX _vkDestroyCuModuleNVX; + PFN_vkDestroyCuFunctionNVX _vkDestroyCuFunctionNVX; + PFN_vkCmdCuLaunchKernelNVX _vkCmdCuLaunchKernelNVX; + PFN_vkGetImageViewHandleNVX _vkGetImageViewHandleNVX; + PFN_vkGetImageViewAddressNVX _vkGetImageViewAddressNVX; + PFN_vkCmdDrawIndirectCountAMD _vkCmdDrawIndirectCountAMD; + PFN_vkCmdDrawIndexedIndirectCountAMD _vkCmdDrawIndexedIndirectCountAMD; + PFN_vkGetShaderInfoAMD _vkGetShaderInfoAMD; + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV _vkGetPhysicalDeviceExternalImageFormatPropertiesNV; + PFN_vkCmdBeginConditionalRenderingEXT _vkCmdBeginConditionalRenderingEXT; + PFN_vkCmdEndConditionalRenderingEXT _vkCmdEndConditionalRenderingEXT; + PFN_vkCmdSetViewportWScalingNV _vkCmdSetViewportWScalingNV; + PFN_vkReleaseDisplayEXT _vkReleaseDisplayEXT; + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT _vkGetPhysicalDeviceSurfaceCapabilities2EXT; + PFN_vkDisplayPowerControlEXT _vkDisplayPowerControlEXT; + PFN_vkRegisterDeviceEventEXT _vkRegisterDeviceEventEXT; + PFN_vkRegisterDisplayEventEXT _vkRegisterDisplayEventEXT; + PFN_vkGetSwapchainCounterEXT _vkGetSwapchainCounterEXT; + PFN_vkGetRefreshCycleDurationGOOGLE _vkGetRefreshCycleDurationGOOGLE; + PFN_vkGetPastPresentationTimingGOOGLE _vkGetPastPresentationTimingGOOGLE; + PFN_vkCmdSetDiscardRectangleEXT _vkCmdSetDiscardRectangleEXT; + PFN_vkCmdSetDiscardRectangleEnableEXT _vkCmdSetDiscardRectangleEnableEXT; + PFN_vkCmdSetDiscardRectangleModeEXT _vkCmdSetDiscardRectangleModeEXT; + PFN_vkSetHdrMetadataEXT _vkSetHdrMetadataEXT; + PFN_vkSetDebugUtilsObjectNameEXT _vkSetDebugUtilsObjectNameEXT; + PFN_vkSetDebugUtilsObjectTagEXT _vkSetDebugUtilsObjectTagEXT; + PFN_vkQueueBeginDebugUtilsLabelEXT _vkQueueBeginDebugUtilsLabelEXT; + PFN_vkQueueEndDebugUtilsLabelEXT _vkQueueEndDebugUtilsLabelEXT; + PFN_vkQueueInsertDebugUtilsLabelEXT _vkQueueInsertDebugUtilsLabelEXT; + PFN_vkCmdBeginDebugUtilsLabelEXT _vkCmdBeginDebugUtilsLabelEXT; + PFN_vkCmdEndDebugUtilsLabelEXT _vkCmdEndDebugUtilsLabelEXT; + PFN_vkCmdInsertDebugUtilsLabelEXT _vkCmdInsertDebugUtilsLabelEXT; + PFN_vkCreateDebugUtilsMessengerEXT _vkCreateDebugUtilsMessengerEXT; + PFN_vkDestroyDebugUtilsMessengerEXT _vkDestroyDebugUtilsMessengerEXT; + PFN_vkSubmitDebugUtilsMessageEXT _vkSubmitDebugUtilsMessageEXT; + PFN_vkCmdSetSampleLocationsEXT _vkCmdSetSampleLocationsEXT; + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT _vkGetPhysicalDeviceMultisamplePropertiesEXT; + PFN_vkGetImageDrmFormatModifierPropertiesEXT _vkGetImageDrmFormatModifierPropertiesEXT; + PFN_vkCreateValidationCacheEXT _vkCreateValidationCacheEXT; + PFN_vkDestroyValidationCacheEXT _vkDestroyValidationCacheEXT; + PFN_vkMergeValidationCachesEXT _vkMergeValidationCachesEXT; + PFN_vkGetValidationCacheDataEXT _vkGetValidationCacheDataEXT; + PFN_vkCmdBindShadingRateImageNV _vkCmdBindShadingRateImageNV; + PFN_vkCmdSetViewportShadingRatePaletteNV _vkCmdSetViewportShadingRatePaletteNV; + PFN_vkCmdSetCoarseSampleOrderNV _vkCmdSetCoarseSampleOrderNV; + PFN_vkCreateAccelerationStructureNV _vkCreateAccelerationStructureNV; + PFN_vkDestroyAccelerationStructureNV _vkDestroyAccelerationStructureNV; + PFN_vkGetAccelerationStructureMemoryRequirementsNV _vkGetAccelerationStructureMemoryRequirementsNV; + PFN_vkBindAccelerationStructureMemoryNV _vkBindAccelerationStructureMemoryNV; + PFN_vkCmdBuildAccelerationStructureNV _vkCmdBuildAccelerationStructureNV; + PFN_vkCmdCopyAccelerationStructureNV _vkCmdCopyAccelerationStructureNV; + PFN_vkCmdTraceRaysNV _vkCmdTraceRaysNV; + PFN_vkCreateRayTracingPipelinesNV _vkCreateRayTracingPipelinesNV; + PFN_vkGetRayTracingShaderGroupHandlesKHR _vkGetRayTracingShaderGroupHandlesKHR; + PFN_vkGetRayTracingShaderGroupHandlesNV _vkGetRayTracingShaderGroupHandlesNV; + PFN_vkGetAccelerationStructureHandleNV _vkGetAccelerationStructureHandleNV; + PFN_vkCmdWriteAccelerationStructuresPropertiesNV _vkCmdWriteAccelerationStructuresPropertiesNV; + PFN_vkCompileDeferredNV _vkCompileDeferredNV; + PFN_vkGetMemoryHostPointerPropertiesEXT _vkGetMemoryHostPointerPropertiesEXT; + PFN_vkCmdWriteBufferMarkerAMD _vkCmdWriteBufferMarkerAMD; + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + PFN_vkGetCalibratedTimestampsEXT _vkGetCalibratedTimestampsEXT; + PFN_vkCmdDrawMeshTasksNV _vkCmdDrawMeshTasksNV; + PFN_vkCmdDrawMeshTasksIndirectNV _vkCmdDrawMeshTasksIndirectNV; + PFN_vkCmdDrawMeshTasksIndirectCountNV _vkCmdDrawMeshTasksIndirectCountNV; + PFN_vkCmdSetExclusiveScissorEnableNV _vkCmdSetExclusiveScissorEnableNV; + PFN_vkCmdSetExclusiveScissorNV _vkCmdSetExclusiveScissorNV; + PFN_vkCmdSetCheckpointNV _vkCmdSetCheckpointNV; + PFN_vkGetQueueCheckpointDataNV _vkGetQueueCheckpointDataNV; + PFN_vkInitializePerformanceApiINTEL _vkInitializePerformanceApiINTEL; + PFN_vkUninitializePerformanceApiINTEL _vkUninitializePerformanceApiINTEL; + PFN_vkCmdSetPerformanceMarkerINTEL _vkCmdSetPerformanceMarkerINTEL; + PFN_vkCmdSetPerformanceStreamMarkerINTEL _vkCmdSetPerformanceStreamMarkerINTEL; + PFN_vkCmdSetPerformanceOverrideINTEL _vkCmdSetPerformanceOverrideINTEL; + PFN_vkAcquirePerformanceConfigurationINTEL _vkAcquirePerformanceConfigurationINTEL; + PFN_vkReleasePerformanceConfigurationINTEL _vkReleasePerformanceConfigurationINTEL; + PFN_vkQueueSetPerformanceConfigurationINTEL _vkQueueSetPerformanceConfigurationINTEL; + PFN_vkGetPerformanceParameterINTEL _vkGetPerformanceParameterINTEL; + PFN_vkSetLocalDimmingAMD _vkSetLocalDimmingAMD; + PFN_vkGetBufferDeviceAddressEXT _vkGetBufferDeviceAddressEXT; + PFN_vkGetPhysicalDeviceToolPropertiesEXT _vkGetPhysicalDeviceToolPropertiesEXT; + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV _vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV _vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; + PFN_vkCreateHeadlessSurfaceEXT _vkCreateHeadlessSurfaceEXT; + PFN_vkCmdSetLineStippleEXT _vkCmdSetLineStippleEXT; + PFN_vkResetQueryPoolEXT _vkResetQueryPoolEXT; + PFN_vkCmdSetCullModeEXT _vkCmdSetCullModeEXT; + PFN_vkCmdSetFrontFaceEXT _vkCmdSetFrontFaceEXT; + PFN_vkCmdSetPrimitiveTopologyEXT _vkCmdSetPrimitiveTopologyEXT; + PFN_vkCmdSetViewportWithCountEXT _vkCmdSetViewportWithCountEXT; + PFN_vkCmdSetScissorWithCountEXT _vkCmdSetScissorWithCountEXT; + PFN_vkCmdBindVertexBuffers2EXT _vkCmdBindVertexBuffers2EXT; + PFN_vkCmdSetDepthTestEnableEXT _vkCmdSetDepthTestEnableEXT; + PFN_vkCmdSetDepthWriteEnableEXT _vkCmdSetDepthWriteEnableEXT; + PFN_vkCmdSetDepthCompareOpEXT _vkCmdSetDepthCompareOpEXT; + PFN_vkCmdSetDepthBoundsTestEnableEXT _vkCmdSetDepthBoundsTestEnableEXT; + PFN_vkCmdSetStencilTestEnableEXT _vkCmdSetStencilTestEnableEXT; + PFN_vkCmdSetStencilOpEXT _vkCmdSetStencilOpEXT; + PFN_vkCopyMemoryToImageEXT _vkCopyMemoryToImageEXT; + PFN_vkCopyImageToMemoryEXT _vkCopyImageToMemoryEXT; + PFN_vkCopyImageToImageEXT _vkCopyImageToImageEXT; + PFN_vkTransitionImageLayoutEXT _vkTransitionImageLayoutEXT; + PFN_vkGetImageSubresourceLayout2EXT _vkGetImageSubresourceLayout2EXT; + PFN_vkReleaseSwapchainImagesEXT _vkReleaseSwapchainImagesEXT; + PFN_vkGetGeneratedCommandsMemoryRequirementsNV _vkGetGeneratedCommandsMemoryRequirementsNV; + PFN_vkCmdPreprocessGeneratedCommandsNV _vkCmdPreprocessGeneratedCommandsNV; + PFN_vkCmdExecuteGeneratedCommandsNV _vkCmdExecuteGeneratedCommandsNV; + PFN_vkCmdBindPipelineShaderGroupNV _vkCmdBindPipelineShaderGroupNV; + PFN_vkCreateIndirectCommandsLayoutNV _vkCreateIndirectCommandsLayoutNV; + PFN_vkDestroyIndirectCommandsLayoutNV _vkDestroyIndirectCommandsLayoutNV; + PFN_vkCmdSetDepthBias2EXT _vkCmdSetDepthBias2EXT; + PFN_vkAcquireDrmDisplayEXT _vkAcquireDrmDisplayEXT; + PFN_vkGetDrmDisplayEXT _vkGetDrmDisplayEXT; + PFN_vkCreatePrivateDataSlotEXT _vkCreatePrivateDataSlotEXT; + PFN_vkDestroyPrivateDataSlotEXT _vkDestroyPrivateDataSlotEXT; + PFN_vkSetPrivateDataEXT _vkSetPrivateDataEXT; + PFN_vkGetPrivateDataEXT _vkGetPrivateDataEXT; + PFN_vkCreateCudaModuleNV _vkCreateCudaModuleNV; + PFN_vkGetCudaModuleCacheNV _vkGetCudaModuleCacheNV; + PFN_vkCreateCudaFunctionNV _vkCreateCudaFunctionNV; + PFN_vkDestroyCudaModuleNV _vkDestroyCudaModuleNV; + PFN_vkDestroyCudaFunctionNV _vkDestroyCudaFunctionNV; + PFN_vkCmdCudaLaunchKernelNV _vkCmdCudaLaunchKernelNV; + PFN_vkGetDescriptorSetLayoutSizeEXT _vkGetDescriptorSetLayoutSizeEXT; + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT _vkGetDescriptorSetLayoutBindingOffsetEXT; + PFN_vkGetDescriptorEXT _vkGetDescriptorEXT; + PFN_vkCmdBindDescriptorBuffersEXT _vkCmdBindDescriptorBuffersEXT; + PFN_vkCmdSetDescriptorBufferOffsetsEXT _vkCmdSetDescriptorBufferOffsetsEXT; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT _vkCmdBindDescriptorBufferEmbeddedSamplersEXT; + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT _vkGetBufferOpaqueCaptureDescriptorDataEXT; + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT _vkGetImageOpaqueCaptureDescriptorDataEXT; + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT _vkGetImageViewOpaqueCaptureDescriptorDataEXT; + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT _vkGetSamplerOpaqueCaptureDescriptorDataEXT; + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT _vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; + PFN_vkCmdSetFragmentShadingRateEnumNV _vkCmdSetFragmentShadingRateEnumNV; + PFN_vkGetDeviceFaultInfoEXT _vkGetDeviceFaultInfoEXT; + PFN_vkCmdSetVertexInputEXT _vkCmdSetVertexInputEXT; + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI _vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; + PFN_vkCmdSubpassShadingHUAWEI _vkCmdSubpassShadingHUAWEI; + PFN_vkCmdBindInvocationMaskHUAWEI _vkCmdBindInvocationMaskHUAWEI; + PFN_vkGetMemoryRemoteAddressNV _vkGetMemoryRemoteAddressNV; + PFN_vkGetPipelinePropertiesEXT _vkGetPipelinePropertiesEXT; + PFN_vkCmdSetPatchControlPointsEXT _vkCmdSetPatchControlPointsEXT; + PFN_vkCmdSetRasterizerDiscardEnableEXT _vkCmdSetRasterizerDiscardEnableEXT; + PFN_vkCmdSetDepthBiasEnableEXT _vkCmdSetDepthBiasEnableEXT; + PFN_vkCmdSetLogicOpEXT _vkCmdSetLogicOpEXT; + PFN_vkCmdSetPrimitiveRestartEnableEXT _vkCmdSetPrimitiveRestartEnableEXT; + PFN_vkCmdSetColorWriteEnableEXT _vkCmdSetColorWriteEnableEXT; + PFN_vkCmdDrawMultiEXT _vkCmdDrawMultiEXT; + PFN_vkCmdDrawMultiIndexedEXT _vkCmdDrawMultiIndexedEXT; + PFN_vkCreateMicromapEXT _vkCreateMicromapEXT; + PFN_vkDestroyMicromapEXT _vkDestroyMicromapEXT; + PFN_vkCmdBuildMicromapsEXT _vkCmdBuildMicromapsEXT; + PFN_vkBuildMicromapsEXT _vkBuildMicromapsEXT; + PFN_vkCopyMicromapEXT _vkCopyMicromapEXT; + PFN_vkCopyMicromapToMemoryEXT _vkCopyMicromapToMemoryEXT; + PFN_vkCopyMemoryToMicromapEXT _vkCopyMemoryToMicromapEXT; + PFN_vkWriteMicromapsPropertiesEXT _vkWriteMicromapsPropertiesEXT; + PFN_vkCmdCopyMicromapEXT _vkCmdCopyMicromapEXT; + PFN_vkCmdCopyMicromapToMemoryEXT _vkCmdCopyMicromapToMemoryEXT; + PFN_vkCmdCopyMemoryToMicromapEXT _vkCmdCopyMemoryToMicromapEXT; + PFN_vkCmdWriteMicromapsPropertiesEXT _vkCmdWriteMicromapsPropertiesEXT; + PFN_vkGetDeviceMicromapCompatibilityEXT _vkGetDeviceMicromapCompatibilityEXT; + PFN_vkGetMicromapBuildSizesEXT _vkGetMicromapBuildSizesEXT; + PFN_vkCmdDrawClusterHUAWEI _vkCmdDrawClusterHUAWEI; + PFN_vkCmdDrawClusterIndirectHUAWEI _vkCmdDrawClusterIndirectHUAWEI; + PFN_vkSetDeviceMemoryPriorityEXT _vkSetDeviceMemoryPriorityEXT; + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE _vkGetDescriptorSetLayoutHostMappingInfoVALVE; + PFN_vkGetDescriptorSetHostMappingVALVE _vkGetDescriptorSetHostMappingVALVE; + PFN_vkCmdCopyMemoryIndirectNV _vkCmdCopyMemoryIndirectNV; + PFN_vkCmdCopyMemoryToImageIndirectNV _vkCmdCopyMemoryToImageIndirectNV; + PFN_vkCmdDecompressMemoryNV _vkCmdDecompressMemoryNV; + PFN_vkCmdDecompressMemoryIndirectCountNV _vkCmdDecompressMemoryIndirectCountNV; + PFN_vkGetPipelineIndirectMemoryRequirementsNV _vkGetPipelineIndirectMemoryRequirementsNV; + PFN_vkCmdUpdatePipelineIndirectBufferNV _vkCmdUpdatePipelineIndirectBufferNV; + PFN_vkGetPipelineIndirectDeviceAddressNV _vkGetPipelineIndirectDeviceAddressNV; + PFN_vkCmdSetDepthClampEnableEXT _vkCmdSetDepthClampEnableEXT; + PFN_vkCmdSetPolygonModeEXT _vkCmdSetPolygonModeEXT; + PFN_vkCmdSetRasterizationSamplesEXT _vkCmdSetRasterizationSamplesEXT; + PFN_vkCmdSetSampleMaskEXT _vkCmdSetSampleMaskEXT; + PFN_vkCmdSetAlphaToCoverageEnableEXT _vkCmdSetAlphaToCoverageEnableEXT; + PFN_vkCmdSetAlphaToOneEnableEXT _vkCmdSetAlphaToOneEnableEXT; + PFN_vkCmdSetLogicOpEnableEXT _vkCmdSetLogicOpEnableEXT; + PFN_vkCmdSetColorBlendEnableEXT _vkCmdSetColorBlendEnableEXT; + PFN_vkCmdSetColorBlendEquationEXT _vkCmdSetColorBlendEquationEXT; + PFN_vkCmdSetColorWriteMaskEXT _vkCmdSetColorWriteMaskEXT; + PFN_vkCmdSetTessellationDomainOriginEXT _vkCmdSetTessellationDomainOriginEXT; + PFN_vkCmdSetRasterizationStreamEXT _vkCmdSetRasterizationStreamEXT; + PFN_vkCmdSetConservativeRasterizationModeEXT _vkCmdSetConservativeRasterizationModeEXT; + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT _vkCmdSetExtraPrimitiveOverestimationSizeEXT; + PFN_vkCmdSetDepthClipEnableEXT _vkCmdSetDepthClipEnableEXT; + PFN_vkCmdSetSampleLocationsEnableEXT _vkCmdSetSampleLocationsEnableEXT; + PFN_vkCmdSetColorBlendAdvancedEXT _vkCmdSetColorBlendAdvancedEXT; + PFN_vkCmdSetProvokingVertexModeEXT _vkCmdSetProvokingVertexModeEXT; + PFN_vkCmdSetLineRasterizationModeEXT _vkCmdSetLineRasterizationModeEXT; + PFN_vkCmdSetLineStippleEnableEXT _vkCmdSetLineStippleEnableEXT; + PFN_vkCmdSetDepthClipNegativeOneToOneEXT _vkCmdSetDepthClipNegativeOneToOneEXT; + PFN_vkCmdSetViewportWScalingEnableNV _vkCmdSetViewportWScalingEnableNV; + PFN_vkCmdSetViewportSwizzleNV _vkCmdSetViewportSwizzleNV; + PFN_vkCmdSetCoverageToColorEnableNV _vkCmdSetCoverageToColorEnableNV; + PFN_vkCmdSetCoverageToColorLocationNV _vkCmdSetCoverageToColorLocationNV; + PFN_vkCmdSetCoverageModulationModeNV _vkCmdSetCoverageModulationModeNV; + PFN_vkCmdSetCoverageModulationTableEnableNV _vkCmdSetCoverageModulationTableEnableNV; + PFN_vkCmdSetCoverageModulationTableNV _vkCmdSetCoverageModulationTableNV; + PFN_vkCmdSetShadingRateImageEnableNV _vkCmdSetShadingRateImageEnableNV; + PFN_vkCmdSetRepresentativeFragmentTestEnableNV _vkCmdSetRepresentativeFragmentTestEnableNV; + PFN_vkCmdSetCoverageReductionModeNV _vkCmdSetCoverageReductionModeNV; + PFN_vkGetShaderModuleIdentifierEXT _vkGetShaderModuleIdentifierEXT; + PFN_vkGetShaderModuleCreateInfoIdentifierEXT _vkGetShaderModuleCreateInfoIdentifierEXT; + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV _vkGetPhysicalDeviceOpticalFlowImageFormatsNV; + PFN_vkCreateOpticalFlowSessionNV _vkCreateOpticalFlowSessionNV; + PFN_vkDestroyOpticalFlowSessionNV _vkDestroyOpticalFlowSessionNV; + PFN_vkBindOpticalFlowSessionImageNV _vkBindOpticalFlowSessionImageNV; + PFN_vkCmdOpticalFlowExecuteNV _vkCmdOpticalFlowExecuteNV; + PFN_vkCreateShadersEXT _vkCreateShadersEXT; + PFN_vkDestroyShaderEXT _vkDestroyShaderEXT; + PFN_vkGetShaderBinaryDataEXT _vkGetShaderBinaryDataEXT; + PFN_vkCmdBindShadersEXT _vkCmdBindShadersEXT; + PFN_vkGetFramebufferTilePropertiesQCOM _vkGetFramebufferTilePropertiesQCOM; + PFN_vkGetDynamicRenderingTilePropertiesQCOM _vkGetDynamicRenderingTilePropertiesQCOM; + PFN_vkSetLatencySleepModeNV _vkSetLatencySleepModeNV; + PFN_vkLatencySleepNV _vkLatencySleepNV; + PFN_vkSetLatencyMarkerNV _vkSetLatencyMarkerNV; + PFN_vkGetLatencyTimingsNV _vkGetLatencyTimingsNV; + PFN_vkQueueNotifyOutOfBandNV _vkQueueNotifyOutOfBandNV; + PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT _vkCmdSetAttachmentFeedbackLoopEnableEXT; + PFN_vkCreateAccelerationStructureKHR _vkCreateAccelerationStructureKHR; + PFN_vkDestroyAccelerationStructureKHR _vkDestroyAccelerationStructureKHR; + PFN_vkCmdBuildAccelerationStructuresKHR _vkCmdBuildAccelerationStructuresKHR; + PFN_vkCmdBuildAccelerationStructuresIndirectKHR _vkCmdBuildAccelerationStructuresIndirectKHR; + PFN_vkBuildAccelerationStructuresKHR _vkBuildAccelerationStructuresKHR; + PFN_vkCopyAccelerationStructureKHR _vkCopyAccelerationStructureKHR; + PFN_vkCopyAccelerationStructureToMemoryKHR _vkCopyAccelerationStructureToMemoryKHR; + PFN_vkCopyMemoryToAccelerationStructureKHR _vkCopyMemoryToAccelerationStructureKHR; + PFN_vkWriteAccelerationStructuresPropertiesKHR _vkWriteAccelerationStructuresPropertiesKHR; + PFN_vkCmdCopyAccelerationStructureKHR _vkCmdCopyAccelerationStructureKHR; + PFN_vkCmdCopyAccelerationStructureToMemoryKHR _vkCmdCopyAccelerationStructureToMemoryKHR; + PFN_vkCmdCopyMemoryToAccelerationStructureKHR _vkCmdCopyMemoryToAccelerationStructureKHR; + PFN_vkGetAccelerationStructureDeviceAddressKHR _vkGetAccelerationStructureDeviceAddressKHR; + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR _vkCmdWriteAccelerationStructuresPropertiesKHR; + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR _vkGetDeviceAccelerationStructureCompatibilityKHR; + PFN_vkGetAccelerationStructureBuildSizesKHR _vkGetAccelerationStructureBuildSizesKHR; + PFN_vkCmdTraceRaysKHR _vkCmdTraceRaysKHR; + PFN_vkCreateRayTracingPipelinesKHR _vkCreateRayTracingPipelinesKHR; + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR _vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; + PFN_vkCmdTraceRaysIndirectKHR _vkCmdTraceRaysIndirectKHR; + PFN_vkGetRayTracingShaderGroupStackSizeKHR _vkGetRayTracingShaderGroupStackSizeKHR; + PFN_vkCmdSetRayTracingPipelineStackSizeKHR _vkCmdSetRayTracingPipelineStackSizeKHR; + PFN_vkCmdDrawMeshTasksEXT _vkCmdDrawMeshTasksEXT; + PFN_vkCmdDrawMeshTasksIndirectEXT _vkCmdDrawMeshTasksIndirectEXT; + PFN_vkCmdDrawMeshTasksIndirectCountEXT _vkCmdDrawMeshTasksIndirectCountEXT; + +}; diff --git a/Src/RenderFramework/Vulkan/VulkanImageView.h b/Src/RenderFramework/Vulkan/VulkanImageView.h new file mode 100644 index 0000000..0d4a12c --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanImageView.h @@ -0,0 +1,48 @@ +#pragma once + +#include "VulkanLogicalDevice.h" + +struct VulkanImageViewCreateInfo : VkImageViewCreateInfo { + VulkanImageViewCreateInfo() { + this->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + this->pNext = nullptr; + this->flags = 0; + } + + static VulkanImageViewCreateInfo image2D(VkImage image, VkFormat format, uint32_t baseMip = 0, uint32_t mipCount = 1, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT) { + VulkanImageViewCreateInfo result; + result.viewType = VK_IMAGE_VIEW_TYPE_2D; + result.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; + result.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; + result.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; + result.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; + result.image = image; + result.format = format; + result.subresourceRange.baseArrayLayer = 0; + result.subresourceRange.layerCount = 1; + result.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + result.subresourceRange.baseMipLevel = 0; + result.subresourceRange.levelCount = 1; + return result; + } +}; + +class VulkanImageView : public RefCountedObject { +public: + VulkanImageView(IntrusivePtr device, VulkanImageViewCreateInfo createInfo):_device(device){ + if (_device->functions().vkCreateImageView(&createInfo, nullptr, &_native) != VK_SUCCESS) { + throw std::runtime_error("failed to create image views!"); + } + } + ~VulkanImageView() { + if(_native != nullptr){ + _device->functions().vkDestroyImageView(_native, nullptr); + } + } + VkImageView native() const { + return _native; + } +private: + IntrusivePtr _device; + VkImageView _native; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanInstance.cpp b/Src/RenderFramework/Vulkan/VulkanInstance.cpp new file mode 100644 index 0000000..f4310c9 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanInstance.cpp @@ -0,0 +1,32 @@ +#include "VulkanInstance.h" + + +std::vector VulkanInstance::enumeratePhysicalDevices() { + auto deviceCount = getPhysicalDeviceCount(); + std::vector devices(deviceCount); + + if (deviceCount == 0) { + return {}; + } + + while (true) { + + auto result = _instanceFunctions.vkEnumeratePhysicalDevices(_instance, &deviceCount, &devices[0]); + if (result == VK_INCOMPLETE) { + deviceCount = getPhysicalDeviceCount(); + } + else if (result == VK_SUCCESS) { + break; + } + else { + throw std::runtime_error("Failed to enumerate physical devices"); + } + } + devices.resize(deviceCount); + + std::vector result; + for (auto& device : devices) { + result.push_back(new VulkanPhysicalDevice(this, device)); + } + return result; +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanInstance.h b/Src/RenderFramework/Vulkan/VulkanInstance.h new file mode 100644 index 0000000..57fbb91 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanInstance.h @@ -0,0 +1,52 @@ +#pragma once + +#include +#include "DynamicLibrary.h" +#include +#include +#include "VulkanApplicationInfo.h" + +#include "VulkanFunctions.h" +#include "VulkanPhysicalDevice.h" +#include "VulkanLibrary.h" +#include "RefCountedObject.h" +#include "VulkanInstanceFunctions.h" + + +//TODO: manage external and internal instance creation and destroy instance in destructor if created internally +class VulkanInstance : public RefCountedObject { +public: + VulkanInstance(IntrusivePtr library, VkInstance instance) : _library(library),_instance(instance){ + _instanceFunctions = VulkanInstanceFunctions([this](const char* name){ return reinterpret_cast(_library->getInstanceProcAddr(_instance, name)); }); + + } + + const VulkanInstanceFunctions& functions() const { + return _instanceFunctions; + } + + VkInstance vkInstance() const { + return _instance; + } + + template>>> + auto getProcAddr(const char* name) const { + return reinterpret_cast(_library->getInstanceProcAddr(_instance, name)); + } + + uint32_t getPhysicalDeviceCount() const { + uint32_t count = 0; + if (_instanceFunctions.vkEnumeratePhysicalDevices(_instance, &count, nullptr) != VK_SUCCESS) { + throw std::runtime_error("Failed to get physical device count"); + } + return count; + } + + std::vector> enumeratePhysicalDevices(); + +private: + VulkanInstanceFunctions _instanceFunctions; + IntrusivePtr _library; + VkInstance _instance = nullptr; +}; + diff --git a/Src/RenderFramework/Vulkan/VulkanInstanceFunctions.h b/Src/RenderFramework/Vulkan/VulkanInstanceFunctions.h new file mode 100644 index 0000000..69e2085 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanInstanceFunctions.h @@ -0,0 +1,423 @@ +#pragma once +#include +#include +class VulkanInstanceFunctions { +public: + VulkanInstanceFunctions(std::function loader){ + _vkDestroyInstance = reinterpret_cast(loader("vkDestroyInstance")); + _vkEnumeratePhysicalDevices = reinterpret_cast(loader("vkEnumeratePhysicalDevices")); + _vkGetPhysicalDeviceFeatures = reinterpret_cast(loader("vkGetPhysicalDeviceFeatures")); + _vkGetPhysicalDeviceFormatProperties = reinterpret_cast(loader("vkGetPhysicalDeviceFormatProperties")); + _vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast(loader("vkGetPhysicalDeviceImageFormatProperties")); + _vkGetPhysicalDeviceProperties = reinterpret_cast(loader("vkGetPhysicalDeviceProperties")); + _vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyProperties")); + _vkGetPhysicalDeviceMemoryProperties = reinterpret_cast(loader("vkGetPhysicalDeviceMemoryProperties")); + _vkGetInstanceProcAddr = reinterpret_cast(loader("vkGetInstanceProcAddr")); + _vkGetDeviceProcAddr = reinterpret_cast(loader("vkGetDeviceProcAddr")); + _vkCreateDevice = reinterpret_cast(loader("vkCreateDevice")); + _vkEnumerateDeviceExtensionProperties = reinterpret_cast(loader("vkEnumerateDeviceExtensionProperties")); + _vkEnumerateDeviceLayerProperties = reinterpret_cast(loader("vkEnumerateDeviceLayerProperties")); + _vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast(loader("vkGetPhysicalDeviceSparseImageFormatProperties")); + _vkEnumeratePhysicalDeviceGroups = reinterpret_cast(loader("vkEnumeratePhysicalDeviceGroups")); + _vkGetPhysicalDeviceFeatures2 = reinterpret_cast(loader("vkGetPhysicalDeviceFeatures2")); + _vkGetPhysicalDeviceProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceProperties2")); + _vkGetPhysicalDeviceFormatProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceFormatProperties2")); + _vkGetPhysicalDeviceImageFormatProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceImageFormatProperties2")); + _vkGetPhysicalDeviceQueueFamilyProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyProperties2")); + _vkGetPhysicalDeviceMemoryProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceMemoryProperties2")); + _vkGetPhysicalDeviceSparseImageFormatProperties2 = reinterpret_cast(loader("vkGetPhysicalDeviceSparseImageFormatProperties2")); + _vkGetPhysicalDeviceExternalBufferProperties = reinterpret_cast(loader("vkGetPhysicalDeviceExternalBufferProperties")); + _vkGetPhysicalDeviceExternalFenceProperties = reinterpret_cast(loader("vkGetPhysicalDeviceExternalFenceProperties")); + _vkGetPhysicalDeviceExternalSemaphoreProperties = reinterpret_cast(loader("vkGetPhysicalDeviceExternalSemaphoreProperties")); + _vkGetPhysicalDeviceToolProperties = reinterpret_cast(loader("vkGetPhysicalDeviceToolProperties")); + _vkDestroySurfaceKHR = reinterpret_cast(loader("vkDestroySurfaceKHR")); + _vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceSupportKHR")); + _vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); + _vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceFormatsKHR")); + _vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfacePresentModesKHR")); + _vkGetPhysicalDevicePresentRectanglesKHR = reinterpret_cast(loader("vkGetPhysicalDevicePresentRectanglesKHR")); + _vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayPropertiesKHR")); + _vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); + _vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast(loader("vkGetDisplayPlaneSupportedDisplaysKHR")); + _vkGetDisplayModePropertiesKHR = reinterpret_cast(loader("vkGetDisplayModePropertiesKHR")); + _vkCreateDisplayModeKHR = reinterpret_cast(loader("vkCreateDisplayModeKHR")); + _vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast(loader("vkGetDisplayPlaneCapabilitiesKHR")); + _vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast(loader("vkCreateDisplayPlaneSurfaceKHR")); + _vkGetPhysicalDeviceVideoCapabilitiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceVideoCapabilitiesKHR")); + _vkGetPhysicalDeviceVideoFormatPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceVideoFormatPropertiesKHR")); + _vkGetPhysicalDeviceFeatures2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceFeatures2KHR")); + _vkGetPhysicalDeviceProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceProperties2KHR")); + _vkGetPhysicalDeviceFormatProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceFormatProperties2KHR")); + _vkGetPhysicalDeviceImageFormatProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceImageFormatProperties2KHR")); + _vkGetPhysicalDeviceQueueFamilyProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyProperties2KHR")); + _vkGetPhysicalDeviceMemoryProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceMemoryProperties2KHR")); + _vkGetPhysicalDeviceSparseImageFormatProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); + _vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast(loader("vkEnumeratePhysicalDeviceGroupsKHR")); + _vkGetPhysicalDeviceExternalBufferPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceExternalBufferPropertiesKHR")); + _vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); + _vkGetPhysicalDeviceExternalFencePropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceExternalFencePropertiesKHR")); + _vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = reinterpret_cast(loader("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); + _vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); + _vkGetPhysicalDeviceSurfaceCapabilities2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceCapabilities2KHR")); + _vkGetPhysicalDeviceSurfaceFormats2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceFormats2KHR")); + _vkGetPhysicalDeviceDisplayProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayProperties2KHR")); + _vkGetPhysicalDeviceDisplayPlaneProperties2KHR = reinterpret_cast(loader("vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); + _vkGetDisplayModeProperties2KHR = reinterpret_cast(loader("vkGetDisplayModeProperties2KHR")); + _vkGetDisplayPlaneCapabilities2KHR = reinterpret_cast(loader("vkGetDisplayPlaneCapabilities2KHR")); + _vkGetPhysicalDeviceFragmentShadingRatesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceFragmentShadingRatesKHR")); + _vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")); + _vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = reinterpret_cast(loader("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")); + _vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = reinterpret_cast(loader("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")); + _vkCreateDebugReportCallbackEXT = reinterpret_cast(loader("vkCreateDebugReportCallbackEXT")); + _vkDestroyDebugReportCallbackEXT = reinterpret_cast(loader("vkDestroyDebugReportCallbackEXT")); + _vkDebugReportMessageEXT = reinterpret_cast(loader("vkDebugReportMessageEXT")); + _vkGetPhysicalDeviceExternalImageFormatPropertiesNV = reinterpret_cast(loader("vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); + _vkReleaseDisplayEXT = reinterpret_cast(loader("vkReleaseDisplayEXT")); + _vkGetPhysicalDeviceSurfaceCapabilities2EXT = reinterpret_cast(loader("vkGetPhysicalDeviceSurfaceCapabilities2EXT")); + _vkCreateDebugUtilsMessengerEXT = reinterpret_cast(loader("vkCreateDebugUtilsMessengerEXT")); + _vkDestroyDebugUtilsMessengerEXT = reinterpret_cast(loader("vkDestroyDebugUtilsMessengerEXT")); + _vkSubmitDebugUtilsMessageEXT = reinterpret_cast(loader("vkSubmitDebugUtilsMessageEXT")); + _vkGetPhysicalDeviceMultisamplePropertiesEXT = reinterpret_cast(loader("vkGetPhysicalDeviceMultisamplePropertiesEXT")); + _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = reinterpret_cast(loader("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); + _vkGetPhysicalDeviceToolPropertiesEXT = reinterpret_cast(loader("vkGetPhysicalDeviceToolPropertiesEXT")); + _vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = reinterpret_cast(loader("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")); + _vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = reinterpret_cast(loader("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")); + _vkCreateHeadlessSurfaceEXT = reinterpret_cast(loader("vkCreateHeadlessSurfaceEXT")); + _vkAcquireDrmDisplayEXT = reinterpret_cast(loader("vkAcquireDrmDisplayEXT")); + _vkGetDrmDisplayEXT = reinterpret_cast(loader("vkGetDrmDisplayEXT")); + _vkGetPhysicalDeviceOpticalFlowImageFormatsNV = reinterpret_cast(loader("vkGetPhysicalDeviceOpticalFlowImageFormatsNV")); + + } + VulkanInstanceFunctions(){} + void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyInstance(instance, pAllocator); + } + VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const { + return _vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); + } + void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const { + _vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const { + _vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) const { + return _vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + } + void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const { + _vkGetPhysicalDeviceProperties(physicalDevice, pProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) const { + _vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const { + _vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); + } + PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) const { + return _vkGetInstanceProcAddr(instance, pName); + } + PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) const { + return _vkGetDeviceProcAddr(device, pName); + } + VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) const { + return _vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); + } + VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) const { + return _vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); + } + VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) const { + return _vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) const { + _vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + } + VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const { + return _vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + } + void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const { + _vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const { + _vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); + } + void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const { + _vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const { + return _vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const { + _vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const { + _vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const { + _vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } + void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const { + _vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + } + void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const { + _vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + } + void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const { + _vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + } + VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) const { + return _vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); + } + void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) const { + _vkDestroySurfaceKHR(instance, surface, pAllocator); + } + VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) const { + return _vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) const { + return _vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); + } + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) const { + return _vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); + } + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) const { + return _vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); + } + VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) const { + return _vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); + } + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) const { + return _vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); + } + VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) const { + return _vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); + } + VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) const { + return _vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); + } + VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) const { + return _vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); + } + VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { + return _vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + } + VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) const { + return _vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); + } + VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) const { + return _vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); + } + void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const { + _vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); + } + void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const { + _vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); + } + void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const { + _vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); + } + VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const { + return _vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const { + _vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const { + _vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); + } + void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const { + _vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } + VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const { + return _vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + } + void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const { + _vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + } + void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const { + _vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + } + void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const { + _vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + } + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const { + return _vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); + } + void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) const { + _vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const { + return _vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); + } + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const { + return _vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); + } + VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) const { + return _vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) const { + return _vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); + } + VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) const { + return _vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); + } + VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) const { + return _vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); + } + VkResult vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) const { + return _vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties); + } + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) const { + return _vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) const { + return _vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); + } + VkResult vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const { + return _vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); + } + void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator); + } + void vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) const { + _vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); + } + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const { + return _vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); + } + VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const { + return _vkReleaseDisplayEXT(physicalDevice, display); + } + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) const { + return _vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); + } + VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) const { + return _vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); + } + void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) const { + _vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); + } + void vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) const { + _vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); + } + void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) const { + _vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); + } + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) const { + return _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); + } + VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) const { + return _vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties); + } + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) const { + return _vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); + } + VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) const { + return _vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); + } + VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { + return _vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); + } + VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const { + return _vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display); + } + VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) const { + return _vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display); + } + VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) const { + return _vkGetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); + } + +private: + PFN_vkDestroyInstance _vkDestroyInstance; + PFN_vkEnumeratePhysicalDevices _vkEnumeratePhysicalDevices; + PFN_vkGetPhysicalDeviceFeatures _vkGetPhysicalDeviceFeatures; + PFN_vkGetPhysicalDeviceFormatProperties _vkGetPhysicalDeviceFormatProperties; + PFN_vkGetPhysicalDeviceImageFormatProperties _vkGetPhysicalDeviceImageFormatProperties; + PFN_vkGetPhysicalDeviceProperties _vkGetPhysicalDeviceProperties; + PFN_vkGetPhysicalDeviceQueueFamilyProperties _vkGetPhysicalDeviceQueueFamilyProperties; + PFN_vkGetPhysicalDeviceMemoryProperties _vkGetPhysicalDeviceMemoryProperties; + PFN_vkGetInstanceProcAddr _vkGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr _vkGetDeviceProcAddr; + PFN_vkCreateDevice _vkCreateDevice; + PFN_vkEnumerateDeviceExtensionProperties _vkEnumerateDeviceExtensionProperties; + PFN_vkEnumerateDeviceLayerProperties _vkEnumerateDeviceLayerProperties; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties _vkGetPhysicalDeviceSparseImageFormatProperties; + PFN_vkEnumeratePhysicalDeviceGroups _vkEnumeratePhysicalDeviceGroups; + PFN_vkGetPhysicalDeviceFeatures2 _vkGetPhysicalDeviceFeatures2; + PFN_vkGetPhysicalDeviceProperties2 _vkGetPhysicalDeviceProperties2; + PFN_vkGetPhysicalDeviceFormatProperties2 _vkGetPhysicalDeviceFormatProperties2; + PFN_vkGetPhysicalDeviceImageFormatProperties2 _vkGetPhysicalDeviceImageFormatProperties2; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 _vkGetPhysicalDeviceQueueFamilyProperties2; + PFN_vkGetPhysicalDeviceMemoryProperties2 _vkGetPhysicalDeviceMemoryProperties2; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 _vkGetPhysicalDeviceSparseImageFormatProperties2; + PFN_vkGetPhysicalDeviceExternalBufferProperties _vkGetPhysicalDeviceExternalBufferProperties; + PFN_vkGetPhysicalDeviceExternalFenceProperties _vkGetPhysicalDeviceExternalFenceProperties; + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties _vkGetPhysicalDeviceExternalSemaphoreProperties; + PFN_vkGetPhysicalDeviceToolProperties _vkGetPhysicalDeviceToolProperties; + PFN_vkDestroySurfaceKHR _vkDestroySurfaceKHR; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR _vkGetPhysicalDeviceSurfaceSupportKHR; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR _vkGetPhysicalDeviceSurfaceCapabilitiesKHR; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR _vkGetPhysicalDeviceSurfaceFormatsKHR; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR _vkGetPhysicalDeviceSurfacePresentModesKHR; + PFN_vkGetPhysicalDevicePresentRectanglesKHR _vkGetPhysicalDevicePresentRectanglesKHR; + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR _vkGetPhysicalDeviceDisplayPropertiesKHR; + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR _vkGetPhysicalDeviceDisplayPlanePropertiesKHR; + PFN_vkGetDisplayPlaneSupportedDisplaysKHR _vkGetDisplayPlaneSupportedDisplaysKHR; + PFN_vkGetDisplayModePropertiesKHR _vkGetDisplayModePropertiesKHR; + PFN_vkCreateDisplayModeKHR _vkCreateDisplayModeKHR; + PFN_vkGetDisplayPlaneCapabilitiesKHR _vkGetDisplayPlaneCapabilitiesKHR; + PFN_vkCreateDisplayPlaneSurfaceKHR _vkCreateDisplayPlaneSurfaceKHR; + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR _vkGetPhysicalDeviceVideoCapabilitiesKHR; + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR _vkGetPhysicalDeviceVideoFormatPropertiesKHR; + PFN_vkGetPhysicalDeviceFeatures2KHR _vkGetPhysicalDeviceFeatures2KHR; + PFN_vkGetPhysicalDeviceProperties2KHR _vkGetPhysicalDeviceProperties2KHR; + PFN_vkGetPhysicalDeviceFormatProperties2KHR _vkGetPhysicalDeviceFormatProperties2KHR; + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR _vkGetPhysicalDeviceImageFormatProperties2KHR; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR _vkGetPhysicalDeviceQueueFamilyProperties2KHR; + PFN_vkGetPhysicalDeviceMemoryProperties2KHR _vkGetPhysicalDeviceMemoryProperties2KHR; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR _vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + PFN_vkEnumeratePhysicalDeviceGroupsKHR _vkEnumeratePhysicalDeviceGroupsKHR; + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR _vkGetPhysicalDeviceExternalBufferPropertiesKHR; + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR _vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR _vkGetPhysicalDeviceExternalFencePropertiesKHR; + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR _vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR _vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR _vkGetPhysicalDeviceSurfaceCapabilities2KHR; + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR _vkGetPhysicalDeviceSurfaceFormats2KHR; + PFN_vkGetPhysicalDeviceDisplayProperties2KHR _vkGetPhysicalDeviceDisplayProperties2KHR; + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR _vkGetPhysicalDeviceDisplayPlaneProperties2KHR; + PFN_vkGetDisplayModeProperties2KHR _vkGetDisplayModeProperties2KHR; + PFN_vkGetDisplayPlaneCapabilities2KHR _vkGetDisplayPlaneCapabilities2KHR; + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR _vkGetPhysicalDeviceFragmentShadingRatesKHR; + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR _vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR _vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR _vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; + PFN_vkCreateDebugReportCallbackEXT _vkCreateDebugReportCallbackEXT; + PFN_vkDestroyDebugReportCallbackEXT _vkDestroyDebugReportCallbackEXT; + PFN_vkDebugReportMessageEXT _vkDebugReportMessageEXT; + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV _vkGetPhysicalDeviceExternalImageFormatPropertiesNV; + PFN_vkReleaseDisplayEXT _vkReleaseDisplayEXT; + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT _vkGetPhysicalDeviceSurfaceCapabilities2EXT; + PFN_vkCreateDebugUtilsMessengerEXT _vkCreateDebugUtilsMessengerEXT; + PFN_vkDestroyDebugUtilsMessengerEXT _vkDestroyDebugUtilsMessengerEXT; + PFN_vkSubmitDebugUtilsMessageEXT _vkSubmitDebugUtilsMessageEXT; + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT _vkGetPhysicalDeviceMultisamplePropertiesEXT; + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + PFN_vkGetPhysicalDeviceToolPropertiesEXT _vkGetPhysicalDeviceToolPropertiesEXT; + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV _vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV _vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; + PFN_vkCreateHeadlessSurfaceEXT _vkCreateHeadlessSurfaceEXT; + PFN_vkAcquireDrmDisplayEXT _vkAcquireDrmDisplayEXT; + PFN_vkGetDrmDisplayEXT _vkGetDrmDisplayEXT; + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV _vkGetPhysicalDeviceOpticalFlowImageFormatsNV; + +}; diff --git a/Src/RenderFramework/Vulkan/VulkanLibrary.cpp b/Src/RenderFramework/Vulkan/VulkanLibrary.cpp new file mode 100644 index 0000000..9de2803 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanLibrary.cpp @@ -0,0 +1,33 @@ +#include "VulkanLibrary.h" +#include "VulkanInstance.h" + +IntrusivePtr VulkanLibrary::createInstance(const VulkanApplicationInfo& info, VkInstanceCreateFlags flags, const std::vector& layers, const std::vector& extensions, VkAllocationCallbacks* allocCallbacks) { + + std::vector _extensions; + for (auto& ext : extensions) { + _extensions.push_back(ext.c_str()); + } + + std::vector _layers; + for (auto& layer : layers) { + _layers.push_back(layer.c_str()); + } + + VkInstanceCreateInfo instance_create_info = { + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + nullptr, + flags, + &info, + static_cast(_layers.size()), + (_layers.size() == 0 ? nullptr : &_layers[0]), + static_cast(_extensions.size()), + (_extensions.size() == 0 ? nullptr : &_extensions[0]) + }; + + VkInstance instance; + if (_functions.vkCreateInstance(&instance_create_info, allocCallbacks, &instance) != VK_SUCCESS) { + return nullptr; + } + + return new VulkanInstance(this, instance); +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanLibrary.h b/Src/RenderFramework/Vulkan/VulkanLibrary.h new file mode 100644 index 0000000..0f949f1 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanLibrary.h @@ -0,0 +1,64 @@ +#pragma once + +#include +#include "VulkanFunctions.h" +#include "VulkanCommon.h" +#include "VulkanApplicationInfo.h" +#include +#include + +#include "RefCountedObject.h" + +class VulkanInstance; + +class VulkanGlobalFunctions { +public: +#define VK_USE_GLOBAL_FUNCTION(name) PFN_##name name; + VK_GLOBAL_FUNCTIONS +#undef VK_USE_GLOBAL_FUNCTION +}; + +class VulkanLibrary : public RefCountedObject { +public: + VulkanLibrary() { + + } + + const VulkanGlobalFunctions& functions() const { + return _functions; + } + + std::vector getSupportedExtensions(const char* layerName = nullptr) const { + uint32_t count = 0; + if ((_functions.vkEnumerateInstanceExtensionProperties(layerName, &count, nullptr) != VK_SUCCESS)) { + throw std::runtime_error("Failed to enumerate extensions"); + } + + std::vector result(count); + if ((_functions.vkEnumerateInstanceExtensionProperties(layerName, &count, &result[0]) != VK_SUCCESS)) { + throw std::runtime_error("Failed to enumerate extensions"); + } + + return result; + } + + std::vector getSupportedLayers() const { + uint32_t count = 0; + if ((_functions.vkEnumerateInstanceLayerProperties(&count, nullptr) != VK_SUCCESS)) { + throw std::runtime_error("Failed to enumerate layers"); + } + + std::vector result(count); + if ((_functions.vkEnumerateInstanceLayerProperties(&count, &result[0]) != VK_SUCCESS)) { + throw std::runtime_error("Failed to enumerate layers"); + } + + return result; + } + + IntrusivePtr createInstance(const VulkanApplicationInfo& info, VkInstanceCreateFlags flags, const std::vector& layers, const std::vector& extensions, VkAllocationCallbacks* allocCallbacks = nullptr); + + PFN_vkGetInstanceProcAddr getInstanceProcAddr; +protected: + VulkanGlobalFunctions _functions; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanLogicalDevice.cpp b/Src/RenderFramework/Vulkan/VulkanLogicalDevice.cpp new file mode 100644 index 0000000..373f0ca --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanLogicalDevice.cpp @@ -0,0 +1,9 @@ +#include "VulkanLogicalDevice.h" + +VkDevice VulkanLogicalDevice::getDevice() const { + return _device; +} + +const VulkanDeviceFunctions& VulkanLogicalDevice::functions() const { + return _functions; +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanLogicalDevice.h b/Src/RenderFramework/Vulkan/VulkanLogicalDevice.h new file mode 100644 index 0000000..241bb06 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanLogicalDevice.h @@ -0,0 +1,127 @@ +#pragma once + +#include +#include "VulkanInstance.h" +#include "VulkanPhysicalDevice.h" +#include +#include +#include "VulkanDeviceFunctions.h" +#include "RefCountedObject.h" +#include "FunctionTraits.h" + +class VulkanQueueCreateInfo { +public: + uint32_t familyIndex; + std::vector priorities; + VulkanQueueCreateInfo(uint32_t familyIndex, const std::vector& priorities):familyIndex(familyIndex), priorities(priorities) {} +}; + +class VulkanLogicalDevice; + +class VulkanQueue { +public: + uint32_t familyID; + uint32_t id; + VkQueue queue; + + VulkanQueue(uint32_t familyID, uint32_t id, VkQueue queue) :familyID(familyID), id(id), queue(queue) { + + } +private: + +}; + +class VulkanLogicalDevice : public RefCountedObject { +public: + VulkanLogicalDevice(IntrusivePtr physicalDevice, const std::vector extensions, const std::vector layers, const std::vector& queues) :_physicalDevice(physicalDevice){ + + VkPhysicalDeviceFeatures deviceFeatures = {}; + + std::vector queueCreateInfo; + queueCreateInfo.reserve(queues.size()); + + for (auto& queue : queues) { + VkDeviceQueueCreateInfo info{}; + info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + info.pNext = nullptr; + info.flags = 0; + info.queueFamilyIndex = queue.familyIndex; + if (queue.priorities.size() == 0) { + throw std::runtime_error("Could not create VkDeviceQueueCreateInfo with zero queues"); + } + + for (auto priority : queue.priorities) { + if (priority < 0.0f || priority > 1.0f) { + throw std::runtime_error("Could not create VkDeviceQueueCreateInfo! Invalid priority set."); + } + } + + info.pQueuePriorities = queue.priorities.data(); + info.queueCount = static_cast(queue.priorities.size()); + + queueCreateInfo.push_back(info); + } + + + VkDeviceCreateInfo createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + createInfo.queueCreateInfoCount = static_cast(queueCreateInfo.size()); + createInfo.pQueueCreateInfos = queueCreateInfo.data(); + createInfo.pEnabledFeatures = &deviceFeatures; + createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.ppEnabledExtensionNames = extensions.size() == 0 ? nullptr : extensions.data(); + createInfo.enabledLayerCount = static_cast(layers.size()); + createInfo.ppEnabledLayerNames = layers.size() == 0 ? nullptr : layers.data(); + + if (physicalDevice->getInstance()->functions().vkCreateDevice(physicalDevice->getDevice(), &createInfo, nullptr, &_device) != VK_SUCCESS) { + throw std::runtime_error("failed to create logical device!"); + } + + _getDeviceProcAddr = reinterpret_cast(_physicalDevice->getInstance()->getProcAddr("vkGetDeviceProcAddr")); + + _functions = VulkanDeviceFunctions([this](const char* name){ return reinterpret_cast(_getDeviceProcAddr(_device, name)); }, _device); + + //get all queues + for (auto& info : queueCreateInfo) { + VkDeviceQueueInfo2 getInfo = {}; + getInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2; + getInfo.queueFamilyIndex = info.queueFamilyIndex; + + for (uint32_t i = 0; i < info.queueCount; ++i) { + getInfo.queueIndex = i; + + VkQueue queue = {}; + _functions.vkGetDeviceQueue(info.queueFamilyIndex, i, &queue); + + _queues.push_back(VulkanQueue{ getInfo.queueFamilyIndex, i, queue }); + } + } + } + + template>>> + auto getProcAddr(const char* name) const { + return reinterpret_cast(_getDeviceProcAddr(_device, name)); + } + + VkDevice getDevice() const; + + const VulkanDeviceFunctions& functions() const; + + const std::vector& queues() const { + return _queues; + } + + IntrusivePtr physicalDevice(){ + return _physicalDevice; + } + + +private: + std::vector _queues; + VulkanDeviceFunctions _functions; + PFN_vkGetDeviceProcAddr _getDeviceProcAddr = nullptr; + IntrusivePtr _physicalDevice; + VkDevice _device = {}; +}; + +using PVulkanLogicalDevice = IntrusivePtr; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanMemory.h b/Src/RenderFramework/Vulkan/VulkanMemory.h new file mode 100644 index 0000000..8ef3ac6 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanMemory.h @@ -0,0 +1,71 @@ +#pragma once + +#include "VulkanLogicalDevice.h" + + +class VulkanMemory : public RefCountedObject { +public: + VulkanMemory(IntrusivePtr device, VkDeviceSize size, std::uint32_t memoryTypeIndex) :_size(size), _memoryTypeIndex(memoryTypeIndex), _device(device){ + VkMemoryAllocateInfo memAlloc = {}; + memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + memAlloc.memoryTypeIndex = memoryTypeIndex; + memAlloc.allocationSize = size; + + if (device->functions().vkAllocateMemory(&memAlloc, nullptr, &_memory) != VK_SUCCESS) { + throw std::runtime_error("Failed to allocate vulkan memory"); + } + } + + ~VulkanMemory() { + _device->functions().vkFreeMemory(_memory, nullptr); + } + + const VkDeviceMemory& native() const { + return _memory; + } + void* map(VkDeviceSize size, VkDeviceSize offset) { + void* result = nullptr; + if (_device->functions().vkMapMemory(_memory, offset, size, 0, &result) != VK_SUCCESS) { + throw std::runtime_error("Failed to map vulkan memory"); + } + return result; + } + + void write(const void* data, VkDeviceSize size, VkDeviceSize offset = 0) { + auto devicePtr = map(size, offset); + memcpy(devicePtr, data, size); + unmap(); + } + + void read(void* data, VkDeviceSize size, VkDeviceSize offset = 0) { + auto devicePtr = map(size, offset); + memcpy(data, devicePtr, size); + unmap(); + } + + std::vector read(VkDeviceSize size, VkDeviceSize offset = 0) { + std::vector result; + result.resize(size); + read(result.data(), result.size(), offset); + return result; + } + + void* map() { + return map(0, _size); + } + void unmap() { + _device->functions().vkUnmapMemory(_memory); + } + VkDeviceSize size() const { + return _size; + } + + std::uint32_t memoryTypeIndex() const { + return _memoryTypeIndex; + } +private: + VkDeviceSize _size; + std::uint32_t _memoryTypeIndex; + VkDeviceMemory _memory{}; + IntrusivePtr _device; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanMemoryProperties.h b/Src/RenderFramework/Vulkan/VulkanMemoryProperties.h new file mode 100644 index 0000000..4147617 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanMemoryProperties.h @@ -0,0 +1,19 @@ +#pragma once +#include +#include +#include + +struct VulkanMemoryProperties : VkPhysicalDeviceMemoryProperties { + std::vector findSuitableMemoryTypeIndices(VkMemoryPropertyFlags properties, std::uint32_t memoryTypeIndexMask = -1) { + std::vector result; + for (std::uint32_t i = 0; i < memoryTypeCount; ++i){ + if ((memoryTypeIndexMask & 1) != 0){ + if ((memoryTypes[i].propertyFlags & properties) == properties){ + result.push_back(i); + } + } + memoryTypeIndexMask >>= 1; + } + return result; + } +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanPhysicalDevice.cpp b/Src/RenderFramework/Vulkan/VulkanPhysicalDevice.cpp new file mode 100644 index 0000000..e457c2d --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanPhysicalDevice.cpp @@ -0,0 +1,70 @@ +#include "VulkanPhysicalDevice.h" +#include "VulkanInstance.h" + +#ifdef WIN32 +#include +#endif + +VulkanPhysicalDevice::VulkanPhysicalDevice(const IntrusivePtr& instance, VkPhysicalDevice device) :_instance(instance), _device(device) { +} + +VkPhysicalDeviceProperties VulkanPhysicalDevice::getProperties() const { + VkPhysicalDeviceProperties result; + _instance->functions().vkGetPhysicalDeviceProperties(_device, &result); + return result; +} +VkPhysicalDeviceFeatures VulkanPhysicalDevice::getFeatures() const { + VkPhysicalDeviceFeatures result; + _instance->functions().vkGetPhysicalDeviceFeatures(_device, &result); + return result; +} + +VulkanMemoryProperties VulkanPhysicalDevice::getMemoryProperties() { + VulkanMemoryProperties result; + _instance->functions().vkGetPhysicalDeviceMemoryProperties(_device, &result); + return result; +} + +std::vector VulkanPhysicalDevice::getQueueFamilyProperties() const { + uint32_t count = getQueueFamiliesCount(); + if (count == 0) { + return {}; + } + + std::vector result(count); + _instance->functions().vkGetPhysicalDeviceQueueFamilyProperties(_device, &count, &result[0]); + return result; +} + +std::vector VulkanPhysicalDevice::getExtensions(const char* layerName) const { + uint32_t extensionCount; + _instance->functions().vkEnumerateDeviceExtensionProperties(_device, layerName, &extensionCount, nullptr); + std::vector availableExtensions(extensionCount); + _instance->functions().vkEnumerateDeviceExtensionProperties(_device, layerName, &extensionCount, availableExtensions.data()); + return availableExtensions; +} + +uint32_t VulkanPhysicalDevice::getQueueFamiliesCount() const { + uint32_t count = 0; + _instance->functions().vkGetPhysicalDeviceQueueFamilyProperties(_device, &count, nullptr); + return count; +} + +VkPhysicalDevice VulkanPhysicalDevice::getDevice() const { + return _device; +} + +IntrusivePtr VulkanPhysicalDevice::getInstance() const { + return _instance; +} + +bool VulkanPhysicalDevice::getPresentationSupport(std::uint32_t queueFamilyIndex) { +#ifdef WIN32 + auto fnGetPresentationSupport = _instance->getProcAddr("vkGetPhysicalDeviceWin32PresentationSupportKHR"); + if (fnGetPresentationSupport == nullptr) { + throw new std::runtime_error("getPresentationSupport: failed to load function"); + } + return fnGetPresentationSupport(_device, queueFamilyIndex) == VK_TRUE; +#endif + throw new std::runtime_error("getPresentationSupport: not implemented"); +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanPhysicalDevice.h b/Src/RenderFramework/Vulkan/VulkanPhysicalDevice.h new file mode 100644 index 0000000..9f9ee09 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanPhysicalDevice.h @@ -0,0 +1,32 @@ +#pragma once + +#include +#include +#include "VulkanQueueFamilyProperties.h" +#include "VulkanCommon.h" +#include "IntrusivePtr.h" +#include "VulkanMemoryProperties.h" +#include "RefCountedObject.h" + +class VulkanInstance; + +class VulkanPhysicalDevice : public RefCountedObject { +public: + VulkanPhysicalDevice(const IntrusivePtr& instance, VkPhysicalDevice device); + VkPhysicalDeviceProperties getProperties() const; + VkPhysicalDeviceFeatures getFeatures() const; + VulkanMemoryProperties getMemoryProperties(); + + + std::vector getQueueFamilyProperties() const; + std::vector getExtensions(const char* layerName = nullptr) const; + uint32_t getQueueFamiliesCount() const; + VkPhysicalDevice getDevice() const; + IntrusivePtr getInstance() const; + + bool getPresentationSupport(std::uint32_t queueFamilyIndex); +private: + IntrusivePtr _instance; + VkPhysicalDevice _device; +}; +using PVulkanPhysicalDevice = IntrusivePtr; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanPipeline.cpp b/Src/RenderFramework/Vulkan/VulkanPipeline.cpp new file mode 100644 index 0000000..034001b --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanPipeline.cpp @@ -0,0 +1,22 @@ +#include "VulkanPipeline.h" +#include "VulkanLogicalDevice.h" + +VulkanPipeline::VulkanPipeline(IntrusivePtr device, IntrusivePtr layout, const VkGraphicsPipelineCreateInfo& createInfo) +:_device(device), _layout(layout){ + if (_device->functions().vkCreateGraphicsPipelines(VK_NULL_HANDLE, 1, &createInfo, nullptr, &_native) != VK_SUCCESS) { + throw std::runtime_error("failed to create graphics pipeline!"); + } +} + +VulkanPipeline::VulkanPipeline(IntrusivePtr device, IntrusivePtr layout, VkPipeline native) + :_device(device), _layout(layout), _native(native){ + +} + +IntrusivePtr VulkanPipeline::layout() { + return _layout; +} + +VulkanPipeline::~VulkanPipeline() { + _device->functions().vkDestroyPipeline(_native, nullptr); +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanPipeline.h b/Src/RenderFramework/Vulkan/VulkanPipeline.h new file mode 100644 index 0000000..c8567c6 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanPipeline.h @@ -0,0 +1,21 @@ +#pragma once + +#include "IntrusivePtr.h" +#include "RefCountedObject.h" +#include +#include "VulkanPipelineLayout.h" + +class VulkanPipeline : public RefCountedObject { +public: + VulkanPipeline(IntrusivePtr device, IntrusivePtr layout, const VkGraphicsPipelineCreateInfo& createInfo); + VulkanPipeline(IntrusivePtr device, IntrusivePtr layout, VkPipeline native); + VkPipeline native() const { + return _native; + } + IntrusivePtr layout(); + ~VulkanPipeline(); +private: + IntrusivePtr _layout; + IntrusivePtr _device; + VkPipeline _native; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanPipelineLayout.cpp b/Src/RenderFramework/Vulkan/VulkanPipelineLayout.cpp new file mode 100644 index 0000000..b41e2fa --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanPipelineLayout.cpp @@ -0,0 +1,20 @@ +#include "VulkanPipelineLayout.h" +#include "VulkanLogicalDevice.h" + +VulkanPipelineLayout::VulkanPipelineLayout(IntrusivePtr device, VkPipelineLayoutCreateInfo& createInfo):_device(device){ + if (_device->functions().vkCreatePipelineLayout(&createInfo, nullptr, &_native) != VK_SUCCESS) { + throw std::runtime_error("failed to create graphics pipeline!"); + } +} + +VulkanPipelineLayout::VulkanPipelineLayout(IntrusivePtr device, VkPipelineLayout native) +:_device(device), _native(native) +{ + +} + +VulkanPipelineLayout::~VulkanPipelineLayout() { + if(_native != nullptr){ + _device->functions().vkDestroyPipelineLayout(_native, nullptr); + } +} \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanPipelineLayout.h b/Src/RenderFramework/Vulkan/VulkanPipelineLayout.h new file mode 100644 index 0000000..701302b --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanPipelineLayout.h @@ -0,0 +1,20 @@ +#pragma once +#include "IntrusivePtr.h" +#include "RefCountedObject.h" +#include + +class VulkanLogicalDevice; + +class VulkanPipelineLayout : public RefCountedObject { +public: + VulkanPipelineLayout(IntrusivePtr device, VkPipelineLayoutCreateInfo& createInfo); + VulkanPipelineLayout(IntrusivePtr device, VkPipelineLayout native); + VkPipelineLayout native() const { + return _native; + } + + ~VulkanPipelineLayout(); +private: + IntrusivePtr _device; + VkPipelineLayout _native; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanQueueFamilyProperties.h b/Src/RenderFramework/Vulkan/VulkanQueueFamilyProperties.h new file mode 100644 index 0000000..9c5e63f --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanQueueFamilyProperties.h @@ -0,0 +1,21 @@ +#pragma once + +#include + +struct VulkanQueueFamilyProperties : VkQueueFamilyProperties { + bool isGraphics() const { + return queueFlags & VK_QUEUE_GRAPHICS_BIT; + } + bool isCompute() const { + return queueFlags & VK_QUEUE_COMPUTE_BIT; + } + bool isTransfer() const { + return queueFlags & VK_QUEUE_TRANSFER_BIT; + } + bool isSparseBinding() const { + return queueFlags & VK_QUEUE_SPARSE_BINDING_BIT; + } + bool isProtected() const { + return queueFlags & VK_QUEUE_PROTECTED_BIT; + } +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanSemaphore.h b/Src/RenderFramework/Vulkan/VulkanSemaphore.h new file mode 100644 index 0000000..7e2ab0a --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanSemaphore.h @@ -0,0 +1,28 @@ +#pragma once + +#include "VulkanLogicalDevice.h" +#include "RefCountedObject.h" + +class VulkanSemaphore : public RefCountedObject{ +public: + VulkanSemaphore(IntrusivePtr device) : _device(device){ + VkSemaphoreCreateInfo semaphoreCreateInfo = {}; + semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + + if (device->functions().vkCreateSemaphore(&semaphoreCreateInfo, nullptr, &_native) != VK_SUCCESS) { + throw std::runtime_error("failed to create semaphore"); + } + } + const VkSemaphore& native() const { + return _native; + } + + ~VulkanSemaphore() { + if(_native != nullptr){ + _device->functions().vkDestroySemaphore(_native, nullptr); + } + } +private: + IntrusivePtr _device; + VkSemaphore _native; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanShaderModule.h b/Src/RenderFramework/Vulkan/VulkanShaderModule.h new file mode 100644 index 0000000..9c87a60 --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanShaderModule.h @@ -0,0 +1,26 @@ +#pragma once + +#include "VulkanLogicalDevice.h" +#include "RefCountedObject.h" + +class VulkanShaderModule : public RefCountedObject { +public: + VulkanShaderModule(IntrusivePtr device, const void* bytecode, uint32_t bytecodeSize):_device(device) { + VkShaderModuleCreateInfo createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + createInfo.codeSize = bytecodeSize; + createInfo.pCode = reinterpret_cast(bytecode); + if (device->functions().vkCreateShaderModule(&createInfo, nullptr, &_shaderModule) != VK_SUCCESS) { + throw std::runtime_error("failed to create shader module!"); + } + } + ~VulkanShaderModule(){ + _device->functions().vkDestroyShaderModule(_shaderModule, nullptr); + } + const VkShaderModule& native() const { + return _shaderModule; + } +private: + IntrusivePtr _device; + VkShaderModule _shaderModule; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/VulkanSwapChain.h b/Src/RenderFramework/Vulkan/VulkanSwapChain.h new file mode 100644 index 0000000..53d405d --- /dev/null +++ b/Src/RenderFramework/Vulkan/VulkanSwapChain.h @@ -0,0 +1,70 @@ +#pragma once + +#include +#include +#include "VulkanInstance.h" +#include "VulkanLogicalDevice.h" + +class VulkanSwapChain { +public: + VulkanSwapChain(IntrusivePtr device, VkSwapchainCreateInfoKHR createInfo):_device(device) { + if (device->functions().vkCreateSwapchainKHR(&createInfo, nullptr, &_swapChain) != VK_SUCCESS) { + throw std::runtime_error("failed to create swap chain!"); + } + uint32_t imageCount = 0; + device->functions().vkGetSwapchainImagesKHR(_swapChain, &imageCount, nullptr); + _images.resize(imageCount); + device->functions().vkGetSwapchainImagesKHR(_swapChain, &imageCount, _images.data()); + + _format = createInfo.imageFormat; + _extent = createInfo.imageExtent; + } + + static std::vector getSurfaceFormats(IntrusivePtr device, VkSurfaceKHR surface) { + uint32_t formatCount; + std::vector result; + + device->getInstance()->functions().vkGetPhysicalDeviceSurfaceFormatsKHR(device->getDevice(), surface, &formatCount, nullptr); + + if (formatCount != 0) { + result.resize(formatCount); + device->getInstance()->functions().vkGetPhysicalDeviceSurfaceFormatsKHR(device->getDevice(), surface, &formatCount, result.data()); + } + return result; + } + + static VkSurfaceCapabilitiesKHR getSurfaceCapabilities(IntrusivePtr device, VkSurfaceKHR surface) { + VkSurfaceCapabilitiesKHR result{}; + device->getInstance()->functions().vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device->getDevice(), surface, &result); + return result; + } + + static std::vector getPresentModes(IntrusivePtr device, VkSurfaceKHR surface) { + std::vector result; + uint32_t presentModeCount = 0; + device->getInstance()->functions().vkGetPhysicalDeviceSurfacePresentModesKHR(device->getDevice(), surface, &presentModeCount, nullptr); + if (presentModeCount != 0) { + result.resize(presentModeCount); + device->getInstance()->functions().vkGetPhysicalDeviceSurfacePresentModesKHR(device->getDevice(), surface, &presentModeCount, result.data()); + } + return result; + } + VkSwapchainKHR native() const { + return _swapChain; + } + const std::vector& images() const { + return _images; + } + VkFormat format() const { + return _format; + } + VkExtent2D extent() const { + return _extent; + } +private: + IntrusivePtr _device; + VkSwapchainKHR _swapChain = {}; + std::vector _images; + VkFormat _format; + VkExtent2D _extent; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/WindowWindows.h b/Src/RenderFramework/Vulkan/WindowWindows.h new file mode 100644 index 0000000..79dade3 --- /dev/null +++ b/Src/RenderFramework/Vulkan/WindowWindows.h @@ -0,0 +1,121 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +class Window { +public: + Window(const std::string& name) { + hInst = GetModuleHandle(NULL);; + MyRegisterClass(hInst); + + hWnd = CreateWindowA(szWindowClass, name.c_str(), WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInst, NULL); + + if (!hWnd) { + throw std::runtime_error("Failed to create window"); + } + SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)this); + ShowWindow(hWnd, SW_SHOWNORMAL); + UpdateWindow(hWnd); + setSize(640, 480); + } + + virtual ~Window() { + + } + + bool update() { + MSG msg = { 0 }; + while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) { + switch (msg.message) { + case WM_QUIT: + return false; + break; + } + TranslateMessage(&msg); + DispatchMessage(&msg); + } + return true; + } + + HWND getHwnd() { + return hWnd; + } + + void setSize(int w, int h) { + RECT NewWindowSize; + NewWindowSize.top = 50; + NewWindowSize.left = 50; + NewWindowSize.bottom = NewWindowSize.top + h; + NewWindowSize.right = NewWindowSize.left + w; + + AdjustWindowRect(&NewWindowSize, WS_OVERLAPPEDWINDOW, false); + SetWindowPos(hWnd, HWND_TOP, NewWindowSize.left, NewWindowSize.top, NewWindowSize.right - NewWindowSize.left, NewWindowSize.bottom - NewWindowSize.top, SWP_SHOWWINDOW | SWP_FRAMECHANGED); + } + + void getClientSize(int& width, int& height) { + RECT r; + GetClientRect(hWnd, &r); + width = r.right - r.left; + height = r.bottom - r.top; + } + + uint32_t getWidth() const { + RECT r; + GetClientRect(hWnd, &r); + return r.right - r.left; + } + + uint32_t getHeight() const { + RECT r; + GetClientRect(hWnd, &r); + return r.bottom - r.top; + } + + std::function messageCallback = nullptr; +private: + ATOM MyRegisterClass(HINSTANCE hInstance) { + WNDCLASSEX wcex; + + wcex.cbSize = sizeof(WNDCLASSEX); + wcex.style = CS_HREDRAW | CS_VREDRAW; + wcex.lpfnWndProc = &Window::WndProc; + wcex.cbClsExtra = 0; + wcex.cbWndExtra = 0; + wcex.hInstance = hInstance; + wcex.hIcon = LoadIcon(wcex.hInstance, IDI_APPLICATION); + wcex.hCursor = LoadCursor(NULL, IDC_ARROW); + wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); + wcex.lpszMenuName = NULL; + wcex.lpszClassName = szWindowClass; + wcex.hIconSm = LoadIcon(wcex.hInstance, IDI_APPLICATION); + + return RegisterClassEx(&wcex); + } + + static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { + + auto window = (Window*)GetWindowLongPtr(hWnd, GWLP_USERDATA); + if (window != nullptr && window->messageCallback) { + window->messageCallback(hWnd, message, wParam, lParam); + } + switch (message) { + case WM_DESTROY: + PostQuitMessage(0); + break; + default: + return DefWindowProc(hWnd, message, wParam, lParam); + } + return 0; + } + + HINSTANCE hInst; + const TCHAR* szWindowClass = TEXT("Window"); + HWND hWnd; +}; \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/extractAllVulkanFunctions.ps1 b/Src/RenderFramework/Vulkan/extractAllVulkanFunctions.ps1 new file mode 100644 index 0000000..dba7301 --- /dev/null +++ b/Src/RenderFramework/Vulkan/extractAllVulkanFunctions.ps1 @@ -0,0 +1,49 @@ +$text = Get-Content "C:\VulkanSDK\1.3.290.0\Include\vulkan\vulkan_core.h" -Raw + +#Write-Host $text + +$AllMatches = [regex]::matches($text, 'typedef\s+([^\s]+)\s+\(\s*VKAPI_PTR\s+\*([^\)]+)\)\s*\(([^\)]+)\)') + +#VulkanFunctions.h + +$DeviceFunctions = New-Object System.Collections.ArrayList +$DeviceCmdFunctions = New-Object System.Collections.ArrayList +$DeviceQueueFunctions = New-Object System.Collections.ArrayList +$InstanceFunctions = New-Object System.Collections.ArrayList + +$UnknownFunctions = New-Object System.Collections.ArrayList + +ForEach ($match in $AllMatches) { + [string]$retval = $match.Groups[1].Value + [string]$name = $match.Groups[2].Value + [string]$params = $match.Groups[3].Value + + #Device instance functions + if($params.StartsWith("VkDevice ") -and ($name -ne 'PFN_vkGetDeviceProcAddr')){ + $DeviceFunctions.Add($match) | Out-Null; + }elseif($params.StartsWith("VkCommandBuffer ")){ + $DeviceCmdFunctions.Add($match) | Out-Null; + }elseif($params.StartsWith("VkQueue ")){ + $DeviceQueueFunctions.Add($match) | Out-Null; + }elseif($params.StartsWith("VkInstance ") -or $params.StartsWith("VkPhysicalDevice ") -or ($name -eq 'PFN_vkGetDeviceProcAddr')){ + $InstanceFunctions.Add($match) | Out-Null; + }elseif(!$name.EndsWith("CallbackEXT") -and !$name.EndsWith("Function") -and !$name.EndsWith("Notification")){ + $UnknownFunctions.Add($match) | Out-Null; + } +} + + +function generateFunctionsGroup($functions, [string]$groupName, [string]$wrapName){ + Write-Host "#define $groupName \" + ForEach ($function in $functions) { + $define = " $wrapName(" + $function.Groups[2].Value.Replace("PFN_", "") + ') \' + Write-Host $define + } + Write-Host "" +} +generateFunctionsGroup $InstanceFunctions "VK_INSTANCE_FUNCTIONS" "VK_USE_INSTANCE_FUNCTION" +generateFunctionsGroup $DeviceFunctions "VK_DEVICE_FUNCTIONS" "VK_USE_DEVICE_FUNCTION" +generateFunctionsGroup $DeviceQueueFunctions "VK_DEVICE_QUEUE_FUNCTIONS" "VK_USE_DEVICE_QUEUE_FUNCTION" +generateFunctionsGroup $DeviceCmdFunctions "VK_DEVICE_CMD_FUNCTIONS" "VK_USE_DEVICE_CMD_FUNCTION" + +generateFunctionsGroup $UnknownFunctions "VK_GLOBAL_FUNCTIONS" "VK_USE_GLOBAL_FUNCTION" \ No newline at end of file diff --git a/Src/RenderFramework/Vulkan/main.cpp b/Src/RenderFramework/Vulkan/main.cpp new file mode 100644 index 0000000..5973d0c --- /dev/null +++ b/Src/RenderFramework/Vulkan/main.cpp @@ -0,0 +1,6 @@ +#include "Application.h" + +// int main() { +// Application app; +// app.run(); +// } \ No newline at end of file diff --git a/Src/RenderFramework/WindowRenderOutput.cpp b/Src/RenderFramework/WindowRenderOutput.cpp new file mode 100644 index 0000000..c0d6144 --- /dev/null +++ b/Src/RenderFramework/WindowRenderOutput.cpp @@ -0,0 +1,242 @@ +#include "WindowRenderOutput.h" +#include +#include +#include +#include "LEngine.h" +/* +std::vector GetDisplayModes(DXGI_FORMAT format, CComPtr output) { + std::vector result; + UINT numStereoModes = 0; + DXGI_MODE_DESC1 modes[1024]; + auto enumFlags = DXGI_ENUM_MODES_STEREO; + + output->GetDisplayModeList1(format, enumFlags, &numStereoModes, 0); + output->GetDisplayModeList1(format, enumFlags, &numStereoModes, modes); + + for (UINT i = 0; i < numStereoModes; ++i) { + result.push_back(modes[i]); + } + return result; +} + +std::vector GetStereoModes(std::vector& modes) { + std::vector result; + for (auto& m : modes) { + if (m.Stereo) { + result.push_back(m); + } + } + return result; +} + +std::vector GetModesByResolution(std::vector& modes, UINT width, UINT height) { + std::vector result; + for (auto& m : modes) { + if (m.Width == width && m.Height == height) { + result.push_back(m); + } + } + return result; +} + +bool FindModeByRefreshRate(UINT targetRate, std::vector& modes, DXGI_MODE_DESC1& mode) { + for (auto& m : modes) { + auto refreshRate = m.RefreshRate.Numerator / m.RefreshRate.Denominator; + int range = 2; + //test if in range + if ((refreshRate >= (targetRate - range)) && (refreshRate <= (targetRate + range))) { + mode = m; + return true; + } + } + return false; +} + + +WindowRenderOutput::WindowRenderOutput(){ + +} + +WindowRenderOutput::~WindowRenderOutput() +{ +} + +Window& WindowRenderOutput::GetWindow() { + return _window; +} + +void WindowRenderOutput::Init(){ + _window.Init();*/ + /*NettleDisplayManager::EDID edid; + NettleDisplayManager::ReadEdidForDxgiOutput(vOutputs[0], edid); + auto& mainEdidBlock = edid.GetMainBlock(); + + auto hSize = mainEdidBlock.detailedTimingDescriptions.detailedTimingDescription1.horizontalBlanking.GetActivePixels(); + auto vSize = mainEdidBlock.detailedTimingDescriptions.detailedTimingDescription1.verticalBlanking.GetActivePixels();*/ + /* + auto hSize = 640; + auto vSize = 480; + + auto backBufferFormat = DXGI_FORMAT_B8G8R8A8_UNORM; + + CComPtr pOutput; + std::vector> vOutputs; + int outputId = 0; + while (LEngine::Instance()->GetRenderer()->GetAdapter()->EnumOutputs(outputId, &pOutput) != DXGI_ERROR_NOT_FOUND) { + vOutputs.push_back(pOutput); + pOutput = nullptr; + ++outputId; + } + + DXGI_OUTPUT_DESC desc; + vOutputs[0]->GetDesc(&desc); + _output = vOutputs[0]; + + CComPtr testOutput; + vOutputs[0].QueryInterface(&testOutput); + auto displayModes = GetDisplayModes(backBufferFormat, testOutput); + //auto stereoModes = GetModesByResolution(GetStereoModes(displayModes), 1920, 1080); + auto stereoModes = GetModesByResolution(displayModes, hSize, vSize); + + DXGI_MODE_DESC1 targetMode = { 0 }; + if (!FindModeByRefreshRate(60, stereoModes, targetMode)) { + FatalError(TEXT("Failed to find 1920 x 1080 stereo 60Hz mode!")); + } + + // Allocate a descriptor. + DXGI_SWAP_CHAIN_DESC1 swapChainDesc = { 0 }; + swapChainDesc.Width = targetMode.Width; + swapChainDesc.Height = targetMode.Height; + swapChainDesc.Format = targetMode.Format; + swapChainDesc.Stereo = targetMode.Stereo; + swapChainDesc.SampleDesc.Count = 1; + swapChainDesc.SampleDesc.Quality = 0; + swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapChainDesc.BufferCount = 1; + swapChainDesc.Scaling = DXGI_SCALING_STRETCH; + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; + swapChainDesc.Flags = 0; + + DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreenDesc = { 0 }; + fullscreenDesc.RefreshRate = targetMode.RefreshRate; + fullscreenDesc.ScanlineOrdering = targetMode.ScanlineOrdering; + fullscreenDesc.Scaling = targetMode.Scaling; + fullscreenDesc.Windowed = TRUE; + + //create swap chain + if (S_OK != LEngine::Instance()->GetRenderer()->GetFactory()->CreateSwapChainForHwnd(LEngine::Instance()->GetRenderer()->GetDevice(), _window.GetHwnd(), &swapChainDesc, &fullscreenDesc, nullptr, &_swapChain)) { + FatalError(TEXT("Failed to create swap chain")); + } + + //get back buffer + + _swapChain->GetBuffer(0, IID_PPV_ARGS(&_backBuffer)); + + //left eye + + CD3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDescLeft(D3D11_RTV_DIMENSION_TEXTURE2DARRAY, DXGI_FORMAT_B8G8R8A8_UNORM, 0, 0, 1); + if (S_OK != LEngine::Instance()->GetRenderer()->GetDevice()->CreateRenderTargetView(_backBuffer, &renderTargetViewDescLeft, &_leftRtv)) { + FatalError(TEXT("Failed to create left eye RTV")); + } + + bool forceStereo = false; + + + D3D11_TEXTURE2D_DESC descDepth; + descDepth.Width = swapChainDesc.Width; + descDepth.Height = swapChainDesc.Height; + descDepth.MipLevels = 1; + descDepth.ArraySize = 1; + descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; + descDepth.SampleDesc.Count = 1; + descDepth.SampleDesc.Quality = 0; + descDepth.Usage = D3D11_USAGE_DEFAULT; + descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL; + descDepth.CPUAccessFlags = 0; + descDepth.MiscFlags = 0; + auto hr = LEngine::Instance()->GetRenderer()->GetDevice()->CreateTexture2D(&descDepth, NULL, &_depthBuffer); + + LEngine::Instance()->GetRenderer()->GetDevice()->CreateDepthStencilView(_depthBuffer, nullptr, &_depthStencilView); + */ + //right eye + /*CD3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDescRight(D3D11_RTV_DIMENSION_TEXTURE2DARRAY, DXGI_FORMAT_B8G8R8A8_UNORM, 0, 1, 1); + if(S_OK != device->CreateRenderTargetView(backBuffer, &renderTargetViewDescRight, &rightRtv)) { + if(forceStereo) { + FatalError(TEXT("Failed to create right eye RTV")); + } else { + rightRtv = nullptr; + } + + }*//* +} + +ID3D11DepthStencilViewPtr WindowRenderOutput::GetDepthStencilView() { + return _depthStencilView; +} + +void WindowRenderOutput::Update() { + _window.ProcessMessages(); +} + +void WindowRenderOutput::OnPreRender(RendererPtr renderer){ + uint32_t w, h; + _window.GetWindowSize(w, h); + D3D11_TEXTURE2D_DESC desc; + _backBuffer->GetDesc(&desc); + + if (desc.Width != w || desc.Height != h) { + _backBuffer = nullptr; + _leftRtv = nullptr; + _rightRtv = nullptr; + auto hr = _swapChain->ResizeBuffers(0, w, h, DXGI_FORMAT_UNKNOWN, 0); + if (hr != S_OK) { + assert(false && "Can't resize BB"); + } + + _swapChain->GetBuffer(0, IID_PPV_ARGS(&_backBuffer)); + + //left eye + CD3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDescLeft(D3D11_RTV_DIMENSION_TEXTURE2DARRAY, DXGI_FORMAT_B8G8R8A8_UNORM, 0, 0, 1); + if (S_OK != renderer->GetDevice()->CreateRenderTargetView(_backBuffer, &renderTargetViewDescLeft, &_leftRtv)) { + FatalError(TEXT("Failed to create left eye RTV")); + } + } + + D3D11_VIEWPORT viewport; + ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT)); + + viewport.TopLeftX = 0; + viewport.TopLeftY = 0; + viewport.Width = (float)w; + viewport.Height = (float)h; + viewport.MinDepth = 0; + viewport.MaxDepth = 1; + + renderer->GetImmediateContext()->RSSetViewports(1, &viewport); +} + +void WindowRenderOutput::Present() { + DXGI_PRESENT_PARAMETERS parameters = { 0 }; + parameters.DirtyRectsCount = 0; + parameters.pDirtyRects = nullptr; + parameters.pScrollRect = nullptr; + parameters.pScrollOffset = nullptr; + HRESULT hr = _swapChain->Present1(0, 0, ¶meters); +} + +uint32_t WindowRenderOutput::GetWidth(){ + D3D11_TEXTURE2D_DESC desc; + _backBuffer->GetDesc(&desc); + return desc.Width; +} + +uint32_t WindowRenderOutput::GetHeight(){ + D3D11_TEXTURE2D_DESC desc; + _backBuffer->GetDesc(&desc); + return desc.Height; +} + +CComPtr WindowRenderOutput::GetRenderTargetView(){ + return _leftRtv; +} +*/ \ No newline at end of file diff --git a/Src/RenderFramework/WindowRenderOutput.h b/Src/RenderFramework/WindowRenderOutput.h new file mode 100644 index 0000000..b59a44a --- /dev/null +++ b/Src/RenderFramework/WindowRenderOutput.h @@ -0,0 +1,32 @@ +#ifndef WindowScreen_h__ +#define WindowScreen_h__ +/* +#include "RenderOutput.h" +#include "Renderer.h" +#include "d3d11_types.h" + +class WindowRenderOutput : public RenderOutput +{ +public: + WindowRenderOutput(); + ~WindowRenderOutput(); + void Init(); + void OnPreRender(RendererPtr renderer) override; + void Present() override; + void Update(); + virtual uint32_t GetWidth() override; + virtual uint32_t GetHeight() override; + virtual ID3D11RenderTargetViewPtr GetRenderTargetView() override; + virtual ID3D11DepthStencilViewPtr GetDepthStencilView() override; + Window& GetWindow(); +private: + Window _window; + IDXGIOutputPtr _output; + ID3D11Texture2DPtr _backBuffer; + ID3D11Texture2DPtr _depthBuffer; + ID3D11RenderTargetViewPtr _leftRtv; + ID3D11RenderTargetViewPtr _rightRtv; + ID3D11DepthStencilViewPtr _depthStencilView; + IDXGISwapChain1Ptr _swapChain; +};*/ +#endif // WindowScreen_h__