From 46337bdeec4848c3807fa79aaa7567ec0fbb0a82 Mon Sep 17 00:00:00 2001 From: l-proger Date: Tue, 13 May 2025 02:24:09 +0300 Subject: [PATCH] * --- .gitignore | 5 + .gitmodules | 20 + .vscode/launch.json | 17 + .vscode/settings.json | 91 + CMake/VulkanTools.cmake | 180 + CMakeLists.txt | 39 + Dependencies/LFramework | 1 + Dependencies/LMath | 1 + Dependencies/SPIRV-Headers | 1 + Dependencies/SPIRV-Tools | 1 + Dependencies/glslang | 1 + Examples/Assets/Boxes.mtl | 26 + Examples/Assets/Boxes.obj | 105 + Examples/Assets/Boxes.obj.meta | 3 + Examples/Assets/Shaders/car_shader.fx | 57 + Examples/Assets/Shaders/default.fx | 64 + Examples/Assets/Shaders/gizmos.fx | 32 + .../Shaders/lighting/cook_torrance_term.inc | 70 + Examples/Assets/Shaders/red_shader.fx | 47 + Examples/Assets/Shaders/shader.fx | 63 + Examples/Assets/Shaders/vk.frag | 10 + Examples/Assets/Shaders/vk.vert | 18 + Examples/Assets/Textures/1_store.dds | Bin 0 -> 349680 bytes Examples/GameEditor/BoundsView.h | 13 + Examples/GameEditor/CMakeLists.txt | 29 + Examples/GameEditor/FreeCameraController.h | 65 + Examples/GameEditor/GameEditor.cpp | Bin 0 -> 9580 bytes Examples/GameEditor/GameEditor.h | 1 + Examples/GameEditor/LFrameworkConfig.h | 4 + README.md | 1 + Src/CMakeLists.txt | 86 + Src/RenderFramework/Archive.cpp | 7 + Src/RenderFramework/Archive.h | 109 + Src/RenderFramework/Asset.h | 45 + Src/RenderFramework/AssetDatabase.cpp | 110 + Src/RenderFramework/AssetDatabase.h | 39 + Src/RenderFramework/AssetFile.h | 226 ++ Src/RenderFramework/AssetImporter.h | 14 + Src/RenderFramework/AssetManager.cpp | 73 + Src/RenderFramework/AssetManager.h | 29 + Src/RenderFramework/AssetMetadata.cpp | 75 + Src/RenderFramework/AssetMetadata.h | 29 + Src/RenderFramework/Bounds.h | 44 + Src/RenderFramework/Camera.cpp | 31 + Src/RenderFramework/Camera.h | 29 + Src/RenderFramework/Component.cpp | 18 + Src/RenderFramework/Component.h | 19 + Src/RenderFramework/FatalError.h | 19 + Src/RenderFramework/File.h | 71 + Src/RenderFramework/Filesystem.h | 14 + Src/RenderFramework/ForwardDeclarations.h | 35 + Src/RenderFramework/ForwardListItem.h | 8 + Src/RenderFramework/GameObject.cpp | 18 + Src/RenderFramework/GameObject.h | 95 + Src/RenderFramework/GizmoVertex.h | 24 + Src/RenderFramework/Gizmos.cpp | 130 + Src/RenderFramework/Gizmos.h | 37 + Src/RenderFramework/Guid.h | 43 + Src/RenderFramework/InputArchive.h | 49 + Src/RenderFramework/LEngine.cpp | 26 + Src/RenderFramework/LEngine.h | 37 + Src/RenderFramework/Material.cpp | 197 ++ Src/RenderFramework/Material.h | 57 + Src/RenderFramework/Mathf.h | 14 + Src/RenderFramework/Mesh.cpp | 148 + Src/RenderFramework/Mesh.h | 49 + Src/RenderFramework/MeshGenerator.cpp | 80 + Src/RenderFramework/MeshGenerator.h | 15 + Src/RenderFramework/MeshRenderer.cpp | 54 + Src/RenderFramework/MeshRenderer.h | 31 + Src/RenderFramework/ModelImporter.h | 34 + Src/RenderFramework/ObjMeshLoader.h | 416 +++ Src/RenderFramework/Object.cpp | 39 + Src/RenderFramework/Object.h | 104 + Src/RenderFramework/ObjectsFactory.cpp | 21 + Src/RenderFramework/ObjectsFactory.h | 58 + Src/RenderFramework/OutputArchive.h | 53 + Src/RenderFramework/RenderOutput.h | 31 + Src/RenderFramework/RenderTargetOutput.cpp | 81 + Src/RenderFramework/RenderTargetOutput.h | 25 + Src/RenderFramework/Renderer.cpp | 219 ++ Src/RenderFramework/Renderer.h | 65 + Src/RenderFramework/Scene.cpp | 14 + Src/RenderFramework/Scene.h | 26 + Src/RenderFramework/SceneRenderer.cpp | 308 ++ Src/RenderFramework/SceneRenderer.h | 20 + Src/RenderFramework/Shader.cpp | 240 ++ Src/RenderFramework/Shader.h | 54 + Src/RenderFramework/ShaderInclude.h | 66 + Src/RenderFramework/ShaderParametersBlock.h | 156 + Src/RenderFramework/Submesh.h | 114 + Src/RenderFramework/SwapChainOutput.h | 122 + Src/RenderFramework/Texture.h | 15 + Src/RenderFramework/TextureImporter.h | 33 + Src/RenderFramework/Transform.h | 94 + Src/RenderFramework/Vertex.h | 27 + Src/RenderFramework/Vulkan/Application.cpp | 775 ++++ Src/RenderFramework/Vulkan/Application.h | 88 + Src/RenderFramework/Vulkan/CMakeLists.txt | 86 + Src/RenderFramework/Vulkan/DynamicLibrary.cpp | 18 + Src/RenderFramework/Vulkan/DynamicLibrary.h | 21 + .../Vulkan/FragmentShader_unknown.h | 14 + Src/RenderFramework/Vulkan/FunctionTraits.h | 76 + Src/RenderFramework/Vulkan/IntrusivePtr.h | 104 + Src/RenderFramework/Vulkan/RefCountedObject.h | 18 + Src/RenderFramework/Vulkan/RenderWindow.h | 19 + .../Vulkan/RenderWindowWindows.cpp | 59 + Src/RenderFramework/Vulkan/ShaderCompiler.h | 82 + Src/RenderFramework/Vulkan/TempFile.h | 72 + Src/RenderFramework/Vulkan/UboPerObjectData.h | 7 + Src/RenderFramework/Vulkan/UniformBuffer.h | 27 + Src/RenderFramework/Vulkan/Vertex.h | 33 + .../Vulkan/VertexShader_unknown.h | 22 + .../Vulkan/VulkanApplicationInfo.h | 15 + Src/RenderFramework/Vulkan/VulkanBuffer.h | 82 + Src/RenderFramework/Vulkan/VulkanCommon.h | 6 + .../Vulkan/VulkanDescriptorSetLayout.cpp | 16 + .../Vulkan/VulkanDescriptorSetLayout.h | 21 + .../Vulkan/VulkanDeviceFunctions.h | 2714 ++++++++++++++ .../Vulkan/VulkanDynamicLibrary.h | 21 + .../Vulkan/VulkanFrameBuffer.cpp | 16 + .../Vulkan/VulkanFrameBuffer.h | 20 + Src/RenderFramework/Vulkan/VulkanFunctions.h | 636 ++++ .../Vulkan/VulkanGlobalFunctions.h | 3143 +++++++++++++++++ Src/RenderFramework/Vulkan/VulkanImageView.h | 48 + Src/RenderFramework/Vulkan/VulkanInstance.cpp | 32 + Src/RenderFramework/Vulkan/VulkanInstance.h | 52 + .../Vulkan/VulkanInstanceFunctions.h | 423 +++ Src/RenderFramework/Vulkan/VulkanLibrary.cpp | 33 + Src/RenderFramework/Vulkan/VulkanLibrary.h | 64 + .../Vulkan/VulkanLogicalDevice.cpp | 9 + .../Vulkan/VulkanLogicalDevice.h | 127 + Src/RenderFramework/Vulkan/VulkanMemory.h | 71 + .../Vulkan/VulkanMemoryProperties.h | 19 + .../Vulkan/VulkanPhysicalDevice.cpp | 70 + .../Vulkan/VulkanPhysicalDevice.h | 32 + Src/RenderFramework/Vulkan/VulkanPipeline.cpp | 22 + Src/RenderFramework/Vulkan/VulkanPipeline.h | 21 + .../Vulkan/VulkanPipelineLayout.cpp | 20 + .../Vulkan/VulkanPipelineLayout.h | 20 + .../Vulkan/VulkanQueueFamilyProperties.h | 21 + Src/RenderFramework/Vulkan/VulkanSemaphore.h | 28 + .../Vulkan/VulkanShaderModule.h | 26 + Src/RenderFramework/Vulkan/VulkanSwapChain.h | 70 + Src/RenderFramework/Vulkan/WindowWindows.h | 121 + .../Vulkan/extractAllVulkanFunctions.ps1 | 49 + Src/RenderFramework/Vulkan/main.cpp | 6 + Src/RenderFramework/WindowRenderOutput.cpp | 242 ++ Src/RenderFramework/WindowRenderOutput.h | 32 + 149 files changed, 15503 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 .vscode/launch.json create mode 100644 .vscode/settings.json create mode 100644 CMake/VulkanTools.cmake create mode 100644 CMakeLists.txt create mode 160000 Dependencies/LFramework create mode 160000 Dependencies/LMath create mode 160000 Dependencies/SPIRV-Headers create mode 160000 Dependencies/SPIRV-Tools create mode 160000 Dependencies/glslang create mode 100644 Examples/Assets/Boxes.mtl create mode 100644 Examples/Assets/Boxes.obj create mode 100644 Examples/Assets/Boxes.obj.meta create mode 100644 Examples/Assets/Shaders/car_shader.fx create mode 100644 Examples/Assets/Shaders/default.fx create mode 100644 Examples/Assets/Shaders/gizmos.fx create mode 100644 Examples/Assets/Shaders/lighting/cook_torrance_term.inc create mode 100644 Examples/Assets/Shaders/red_shader.fx create mode 100644 Examples/Assets/Shaders/shader.fx create mode 100644 Examples/Assets/Shaders/vk.frag create mode 100644 Examples/Assets/Shaders/vk.vert create mode 100644 Examples/Assets/Textures/1_store.dds create mode 100644 Examples/GameEditor/BoundsView.h create mode 100644 Examples/GameEditor/CMakeLists.txt create mode 100644 Examples/GameEditor/FreeCameraController.h create mode 100644 Examples/GameEditor/GameEditor.cpp create mode 100644 Examples/GameEditor/GameEditor.h create mode 100644 Examples/GameEditor/LFrameworkConfig.h create mode 100644 README.md create mode 100644 Src/CMakeLists.txt create mode 100644 Src/RenderFramework/Archive.cpp create mode 100644 Src/RenderFramework/Archive.h create mode 100644 Src/RenderFramework/Asset.h create mode 100644 Src/RenderFramework/AssetDatabase.cpp create mode 100644 Src/RenderFramework/AssetDatabase.h create mode 100644 Src/RenderFramework/AssetFile.h create mode 100644 Src/RenderFramework/AssetImporter.h create mode 100644 Src/RenderFramework/AssetManager.cpp create mode 100644 Src/RenderFramework/AssetManager.h create mode 100644 Src/RenderFramework/AssetMetadata.cpp create mode 100644 Src/RenderFramework/AssetMetadata.h create mode 100644 Src/RenderFramework/Bounds.h create mode 100644 Src/RenderFramework/Camera.cpp create mode 100644 Src/RenderFramework/Camera.h create mode 100644 Src/RenderFramework/Component.cpp create mode 100644 Src/RenderFramework/Component.h create mode 100644 Src/RenderFramework/FatalError.h create mode 100644 Src/RenderFramework/File.h create mode 100644 Src/RenderFramework/Filesystem.h create mode 100644 Src/RenderFramework/ForwardDeclarations.h create mode 100644 Src/RenderFramework/ForwardListItem.h create mode 100644 Src/RenderFramework/GameObject.cpp create mode 100644 Src/RenderFramework/GameObject.h create mode 100644 Src/RenderFramework/GizmoVertex.h create mode 100644 Src/RenderFramework/Gizmos.cpp create mode 100644 Src/RenderFramework/Gizmos.h create mode 100644 Src/RenderFramework/Guid.h create mode 100644 Src/RenderFramework/InputArchive.h create mode 100644 Src/RenderFramework/LEngine.cpp create mode 100644 Src/RenderFramework/LEngine.h create mode 100644 Src/RenderFramework/Material.cpp create mode 100644 Src/RenderFramework/Material.h create mode 100644 Src/RenderFramework/Mathf.h create mode 100644 Src/RenderFramework/Mesh.cpp create mode 100644 Src/RenderFramework/Mesh.h create mode 100644 Src/RenderFramework/MeshGenerator.cpp create mode 100644 Src/RenderFramework/MeshGenerator.h create mode 100644 Src/RenderFramework/MeshRenderer.cpp create mode 100644 Src/RenderFramework/MeshRenderer.h create mode 100644 Src/RenderFramework/ModelImporter.h create mode 100644 Src/RenderFramework/ObjMeshLoader.h create mode 100644 Src/RenderFramework/Object.cpp create mode 100644 Src/RenderFramework/Object.h create mode 100644 Src/RenderFramework/ObjectsFactory.cpp create mode 100644 Src/RenderFramework/ObjectsFactory.h create mode 100644 Src/RenderFramework/OutputArchive.h create mode 100644 Src/RenderFramework/RenderOutput.h create mode 100644 Src/RenderFramework/RenderTargetOutput.cpp create mode 100644 Src/RenderFramework/RenderTargetOutput.h create mode 100644 Src/RenderFramework/Renderer.cpp create mode 100644 Src/RenderFramework/Renderer.h create mode 100644 Src/RenderFramework/Scene.cpp create mode 100644 Src/RenderFramework/Scene.h create mode 100644 Src/RenderFramework/SceneRenderer.cpp create mode 100644 Src/RenderFramework/SceneRenderer.h create mode 100644 Src/RenderFramework/Shader.cpp create mode 100644 Src/RenderFramework/Shader.h create mode 100644 Src/RenderFramework/ShaderInclude.h create mode 100644 Src/RenderFramework/ShaderParametersBlock.h create mode 100644 Src/RenderFramework/Submesh.h create mode 100644 Src/RenderFramework/SwapChainOutput.h create mode 100644 Src/RenderFramework/Texture.h create mode 100644 Src/RenderFramework/TextureImporter.h create mode 100644 Src/RenderFramework/Transform.h create mode 100644 Src/RenderFramework/Vertex.h create mode 100644 Src/RenderFramework/Vulkan/Application.cpp create mode 100644 Src/RenderFramework/Vulkan/Application.h create mode 100644 Src/RenderFramework/Vulkan/CMakeLists.txt create mode 100644 Src/RenderFramework/Vulkan/DynamicLibrary.cpp create mode 100644 Src/RenderFramework/Vulkan/DynamicLibrary.h create mode 100644 Src/RenderFramework/Vulkan/FragmentShader_unknown.h create mode 100644 Src/RenderFramework/Vulkan/FunctionTraits.h create mode 100644 Src/RenderFramework/Vulkan/IntrusivePtr.h create mode 100644 Src/RenderFramework/Vulkan/RefCountedObject.h create mode 100644 Src/RenderFramework/Vulkan/RenderWindow.h create mode 100644 Src/RenderFramework/Vulkan/RenderWindowWindows.cpp create mode 100644 Src/RenderFramework/Vulkan/ShaderCompiler.h create mode 100644 Src/RenderFramework/Vulkan/TempFile.h create mode 100644 Src/RenderFramework/Vulkan/UboPerObjectData.h create mode 100644 Src/RenderFramework/Vulkan/UniformBuffer.h create mode 100644 Src/RenderFramework/Vulkan/Vertex.h create mode 100644 Src/RenderFramework/Vulkan/VertexShader_unknown.h create mode 100644 Src/RenderFramework/Vulkan/VulkanApplicationInfo.h create mode 100644 Src/RenderFramework/Vulkan/VulkanBuffer.h create mode 100644 Src/RenderFramework/Vulkan/VulkanCommon.h create mode 100644 Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanDescriptorSetLayout.h create mode 100644 Src/RenderFramework/Vulkan/VulkanDeviceFunctions.h create mode 100644 Src/RenderFramework/Vulkan/VulkanDynamicLibrary.h create mode 100644 Src/RenderFramework/Vulkan/VulkanFrameBuffer.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanFrameBuffer.h create mode 100644 Src/RenderFramework/Vulkan/VulkanFunctions.h create mode 100644 Src/RenderFramework/Vulkan/VulkanGlobalFunctions.h create mode 100644 Src/RenderFramework/Vulkan/VulkanImageView.h create mode 100644 Src/RenderFramework/Vulkan/VulkanInstance.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanInstance.h create mode 100644 Src/RenderFramework/Vulkan/VulkanInstanceFunctions.h create mode 100644 Src/RenderFramework/Vulkan/VulkanLibrary.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanLibrary.h create mode 100644 Src/RenderFramework/Vulkan/VulkanLogicalDevice.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanLogicalDevice.h create mode 100644 Src/RenderFramework/Vulkan/VulkanMemory.h create mode 100644 Src/RenderFramework/Vulkan/VulkanMemoryProperties.h create mode 100644 Src/RenderFramework/Vulkan/VulkanPhysicalDevice.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanPhysicalDevice.h create mode 100644 Src/RenderFramework/Vulkan/VulkanPipeline.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanPipeline.h create mode 100644 Src/RenderFramework/Vulkan/VulkanPipelineLayout.cpp create mode 100644 Src/RenderFramework/Vulkan/VulkanPipelineLayout.h create mode 100644 Src/RenderFramework/Vulkan/VulkanQueueFamilyProperties.h create mode 100644 Src/RenderFramework/Vulkan/VulkanSemaphore.h create mode 100644 Src/RenderFramework/Vulkan/VulkanShaderModule.h create mode 100644 Src/RenderFramework/Vulkan/VulkanSwapChain.h create mode 100644 Src/RenderFramework/Vulkan/WindowWindows.h create mode 100644 Src/RenderFramework/Vulkan/extractAllVulkanFunctions.ps1 create mode 100644 Src/RenderFramework/Vulkan/main.cpp create mode 100644 Src/RenderFramework/WindowRenderOutput.cpp create mode 100644 Src/RenderFramework/WindowRenderOutput.h 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 0000000000000000000000000000000000000000..93d630a232125c545c2a4b98e8d2f99a7f2a2147 GIT binary patch literal 349680 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 ZhyGuz4~V>leH=AQ`7?@hNj}o={{xg<%{Kr5 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..bd67027fe5087fdbbe97b60e7e32a57eb9af4a44 GIT binary patch literal 9580 zcmb_iYfl?j5WQbrssF)prD~HlHUt`>lp;|`(nxtANZLwiWC7;k#z5p<9%+=n-u9e3 zJD%CyYeO)K4EXNcdA~RR{rg=QhSRVgM&UdR!a-<<)$m6=8-%lP8S>B#$6+me8@>rC z*aCNt!)_Q~1Gf#_r;)-qJO%V_IKjy!XpF;$&^_lS2HT*j4g};GuACk|9aR)eP!-L?p zb1=8%*CA~VtVMVUo=@?iwdVCFky~~70)DnzdfzN9bfRw_fc{3QKYHp0Zl8j`F@BHm zPr2(%jfzn?1a#fUp970{UoY6-v-nw!(M7ta_)Lq!PWTm1&jB-lCVxi^F|vqvI)`V` zFZRGAbw8U2Z|_tzm<2b1ufXT7@zRdOJ1Ftb$FGmob=Zj+Y#1)))`QvfF0q<+=abs- zJcYFM;@S8ZmGt=o==`MgJyrq#NoAR>c&m-5k-G&jY`{DB@H-3lP+>kt94+8wK0d?A ze)-&It9JMWPf`>fhsU^K*opP$5@!n218~0%-x@c#m5OshT(`Z;I^t^jYM9lo&ItgMv>rrMG^B7HEfaz*Ek4 z_=4XiG4)X3=@{~)H7UCJGO?W4^&C1ZaN|wnj@8jBMH{@dW3JkRrwjqvu02;9p5rO? zxDxsiTlIT?Vi!GM43BD%deVel3J+_rdeVe_6qakSdSbAYdl0oO8X)IKkj#HeL9+{@ z1r)yeU2iZhS`kudNMCdSntkY!7*>ha^rYcx;?ccqtQdN4_w6!wVT+tkCW=TS+D-2 zX{+mKn8g&A*Spb9>%Rr26=q(M z4w#v;3mP9m_Y@LSUg^F1=vbsGWDdLcM#Hc5gC3^$Gh}M|$^hD049r;%{b9_5QY<`NG zSxr_QsRwnw*^}IaYsw|^(ZjDtz?5k+#3Tj117DTq8Z87cDJqv?!eyejc$ zn7upbS$1Pwu!FE09q3bYnLj5#v%9Jdhs8Q6TKA%qWI6nVT(kg-&!WJp$;in|&p3&6 zr6c21N3KR;3xDO{pP8K*Gz0Vqe=*lD;oCwzRb6@1)r0@6h3?s6-5qmO)hL2Fsk?qoiiz>G3G|76ZyEw)0D%h-47tW%endoSJ7-C(!uS&JG4^PD=jsYvS7Zu?HX z+F!Br(vCuP*O~O~7M)#isk5KDJ>iIA6iZ3Qjn=ybZ5P2v&fq9^Rokys!B#rI;4g z)B|e`r!F7iI)`zJStz^S75wEblFA;Q8^LGu3bW=1(CLGsO_QsMeBv#_N^^6&QX{iu z6)X6BrQRS{!_L&!0L46?y6E!4S`Esd9j{iu1Z*QKu*=Kpoiy}3p; z=Ia=I-4@QJU)DX2#v|jTU3MK3IU3~_frpTV(~WvDI~VpS$GG`*Rrv_IEa3No&uX6H z%aHH56}|!--{DAqZaLa(kI#hu2ymKzyOT`AZfY9eYLONqrWdJ5Jk9P7Q~T+6Qs89BHrIWp~&H+zFI zt;$k2>NTtn-1~5U$8Ls|UvTRg>)>L{0McP_Z_Al8k36c6iH3+-qLO}~Zy-clIsAe4 z-A6`YtahO%`cR#N4sZ{l1KOMs+lf&vJgK#<_NL}F&MMp=(y#87UD@aIcMGS+M5)=yO9$2?!)N0k{|6J zDe}GHWsG;h!VL@YNb_R^taEXlEG^`!X%hGyz&&t~0hYZ4-)OK8nQo;4pyaKLY!m!uc>1jq=z(vgxQSq- za&l*uW?gGa_W)XHT98?pH~B7?(-vpt9zKhR3;V~diRKS#v57}Kp-xpjpatAb>-`X` zYf7JXk99$;*}T6N?=OKj+3INKZ%y9!kymyJ)4MfBK6S`1&qp z<)L-5lL^42GwA73@J=cROZSng>&-er9I5VJ{bbfu@)i@J{BHnuO^cOypk-!nj3^-^ lnbE56rOm6PleMXX&|A?f8QB_{3UB+aR)n#4v6>47;(s+93-tg1 literal 0 HcmV?d00001 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__