gfxstream: mega-change to support guest Linux WSI with gfxstream
This is a mega-change to support Linux guest WSI with gfxstream.
We tried to do a branch where every commit was buildable and
runnable, but that quickly proved unworkable. So we squashed
the branch into a mega-change.
Zink provides the GL implementation for Linux guests, so we just
needed to implement the proper Vulkan Wayland/X11 WSI
entrypoints.
The overall strategy to support this is to use Mesa's WSI
functions. The Vulkan WSI layer was also considered:
https://gitlab.freedesktop.org/mesa/vulkan-wsi-layer
But it was less maintained compared to Mesa. The way Mesa common
layers communicate with drivers is the through base objects
embedded in driver and a common dispatch layer:
https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/docs/vulkan/dispatch.rst
https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/docs/vulkan/base-objs.rst
Our objects are defined in gfxstream_vk_private.h. Currently,
Mesa-derived Vulkan objects just serve as shim to gfxstream
Vulkan’s internal handle mapping. Long-term, we can use
Mesa-derived objects inside gfxstream guest Vulkan exclusively.
The flow is typically inside a Vulkan entrypoint is:
- VK_FROM_HANDLE(vk-object) to convert to a gfxstream_vk_obj
object
- Call ResourceTracker::func(gfxstream_vk_obj->internal) or
VkEncoder::func(gfxstream_vk_obj>internal)
- Return result
A good follow-up cleanup would be to delete older gfxstream
objects. For example, we now have struct gfxstream_vk_device
and info_VkDevice in ResourceTracker.
Most of this logic was auto-generated and included in
func_table.cpp. Some vulkan functions were too difficult to
auto-generate or required special logic, and these are included
in gfxstream_vk_device.cpp. For example, anything that needs to
setup the HostConnection requires special handling.
Android Blueprint support is added to the parts of Mesa needed
to build the Vulkan runtime. One thing to call out it's
required to build the guest/vulkan_enc and guest/vulkan files
in the same shared library now, when previously have
libvulkan_enc.so and libvulkan_ranchu.so was sufficient
[otherwise, some weak pointer logic wouldn't work].
A side effect of this is libOpenglSystem must also be a static
lib, and so should libandroid_aemu too. That conceptually makes
sense and the Meson build had been doing this all a long. We
can probably transition everything besides libGLESv1_emulation.so,
libGLESv2_emulation.so and libvulkan_ranchu.so to be static.
This requires changes in the end2end tests, because since each
HostConnection is separate and internal to it's constituent
library. Lifetimes need to be managed separately: for example
the HostConnection instance created by the end2end tests would
not be visible inside libvulkan_ranchu.so anymore. Probably the
best solution would be improve the testing facade so a
HostConnection represents one virtio-gpu context, while some
other entity represents a virtio-gpu device (client-server
would work).
vk.xml was modified, but change sent to Khronos:
https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/6325
Fuchsia builds still need to be migrated, but they already have
Fuchsia Mesa with all the build rules so that shouldn't be too
bad. Just need to copy them over the gfxstream/Mesa hybrid.
The new command for building Linux guests is:
meson amd64-build/ -Dvulkan-drivers="gfxstream" -Dgallium-drivers="" -Dvk-no-nir=true -Dopengl=false
Big shout-out to Aaron Ruby, who did most of the gnarly codegen
needed to get the function table logic to work.
BUG=313466265
BUG=298679844
TEST=
* Run Weston/vkcube on Linux and automotive platform
* launch_cvd --gpu_mode=gfxstream vkcube
* launch_cvd --gpu_mod=gfxstream_guest_angle
* vkcube + 3D Mark Slingshot extreme work with guest ANGLE and
GL-VK interop
* GfxstreamEnd2EndTests
* Some select dEQP tests
Aaron Ruby (46):
gfxstream: function table: remove entry points that are hand-written.
gfxstream: function table: more changes
gfxstream: function table: scope internal_arrays to encoder
gfxstream: function table: autogenerate compoundType params
gfxstream: add handwritten EnumeratePhysicalDeviceGroup entrypoint.
gfxstream: function table: handle nested handle arrays
gfxstream: function table: adding some handwritten implementations
gfxstream: revert some unnecessary changes
gfxstream: use vk_object_zalloc/free instead of vk_zalloc/free.
gfxstream: revert most gfxstream objects to use vk_object_base
gfxstream: function table: handwritten commmand-buffers/pools
gfxstream: codegen functionality to handle special param
gfxstream: function table: random fixes
gfxstream: add vk_command_buffer_ops handlers
gfxstream: func_table.py: Codegen support for nested compound type
gfxstream: remove handwritten/add autogen entry points
gfxstream: add gfxstream_vk_device.cpp
gfxstream: query device and instance extensions early
gfxstream: func_table: explicit allocation for nested arrays/compound
types
gfxstream: goldfish_vulkan: fix commandBuffer allocation.
gfxstream: meson: Raise api_version in ICD config to 1.1.
gfxstream: function table: add more handwritten entries
gfxstream: goldfish_vulkan: update VkDescriptorSetAllocateInfo logic
gfxstream: function table: NULL check on internal_object dereference
gfxstream: function table: Remove POSTPROCESSES handling from
functable
gfxstream: mesa: Add 'gfxstream' as a -Dvulkan-drivers
gfxstream: ResourceTracker: add some allowedExtensions
gfxstream: gfxstream_vk_device: add wsi_common_entrypoints
gfxstream: Move instance handling into gfxstream_vk_device.cpp
gfxstream: ResourceTracker: Enable Linux WSI-related extensions
gfxstream: wsi: add wsi_device initialization
gfxstream: gfxstream_vk_device: use Mesa common physical device
management
gfxstream: ResourceTracker: translate mesa objects in user buffer
gfxstream: exclude VkSampler and VkDescriptorSet objects from
translation
gfxstream: Add guest-side external memory support with colorBuffers.
gfxstream: function table: Modify semaphoreList inputs to no-op
semaphores
gfxstream: function table: Allow VK_NULL_HANDLE for free/destroy APIs.
gfxstream: cereal: Add VK_EXT_depth_clip_enable as supported feature.
gfxstream: vulkan_enc: un-namespace vk_util.h and vk_struct_id.h
gfxstream: gfxstream_vk_device.cpp: Support VK_KHR_surface and
VK_*_surface
gfxstream: vulkan_enc: Add support for Mesa-only extensions.
gfxstream: ResourceTracker: Use DEVICE_TYPE_VIRTUAL_GPU always
gfxstream: platform: add dma-buf export support with dedicatedBuffer.
gfxstream: ResourceTracker: add VK_EXT_depth_clip_enable allowed
extension
gfxstream: ResourceTracker: external memory via QNX_screen_buffer
extension
gfxstream: Add VK_QNX_external_memory_screen_buffer to VulkanDispatch
Gurchetan Singh (18):
gfxstream: mesa: write Android.bp files
gfxstream: generate gfxstream_vk_entrypoints.{c, h}
gfxstream: vulkan_enc: add gfxstream_vk_private.h (objects)
gfxstream: function table: modify function table to use gfxstream_vk_*
gfxstream: compiles
gfxstream: build system improvements
gfxstream: ResourceTracker: don't crash without
VkBindImageMemorySwapchainInfoKHR
gfxstream: vk.xml: make some vkAcquireImageANDROID params optional
gfxstream_vk_device: filter out swapchain maintenance guest side
gfxstream: end2end: fixes for End2End tests
gfxstream: func_table: custom vkEnumerateInstanceLayerProperties
gfxstream: add VK_EXT_DEBUG_UTILS_EXTENSION_NAME into Mesa list
gfxstream: clang-format guest code
gfxstream: libandroid AEMU static
gfxstream: vkEnumerateInstanceVersion
gfxstream: vkCreateComputePipeLines
gfxstream: make end2end tests happy
gfxstream: delete prior vk.xml, vk_icd_gen.py
Change-Id: Ic4cc50d5098dddd77c9265afa8f432a2fdea8845
diff --git a/README.md b/README.md
index 4f38628..b356997 100644
--- a/README.md
+++ b/README.md
@@ -9,25 +9,14 @@
# Build: Linux
-Make sure the latest CMake is installed.
-Make sure the opengl lib is installed. Otherwise, sudo apt-get install
-libglu1-mesa-dev freeglut3-dev mesa-common-dev
-Make sure you are using Clang as your `CC` and clang++ as your`CXX`. Then
-
- mkdir build
- cd build
- cmake . ../
- make -j24
-
-Unit tests:
-
- make test
+The latest directions for the standalone Linux build are provided
+[here](https://crosvm.dev/book/appendix/rutabaga_gfx.html).
# Build: Windows
Make sure the latest CMake is installed. Make sure Visual Studio 2019 is
installed on your system along with all the Clang C++ toolchain components.
-Then
+Then:
mkdir build
cd build
@@ -38,7 +27,7 @@
# Build: Android for host
-Be in the Android build system. Then
+Be in the Android build system. Then:
m libgfxstream_backend
@@ -52,31 +41,27 @@
# Regenerating Vulkan code
-Check out the [gfxstream-protocols](https://android.googlesource.com/platform/external/gfxstream-protocols/)
-repo at `../../../external/gfxstream-protocols` relative to the root directory of this repo, and
-run the `scripts/generate-vulkan-sources.sh` script in the `gfxstream-protocols` root folder.
+To re-generate both guest and Vulkan code, please run:
-If you're in an AOSP checkout, this will also modify contents of the guest Vulkan encoder in `../goldfish-opengl`.
+ scripts/generate-gfxstream-vulkan.sh
# Regenerating GLES/RenderControl code
-First, build `build/gfxstream-generic-apigen`. Then run
+First, build `build/gfxstream-generic-apigen`. Then run:
scripts/generate-apigen-source.sh
# Tests
-## Linux Tests
-
-There are a bunch of test executables generated. They require `libEGL.so` and `libGLESv2.so` and `libvulkan.so` to be available, possibly from your GPU vendor or ANGLE, in the `$LD_LIBRARY_PATH`.
-
## Windows Tests
There are a bunch of test executables generated. They require `libEGL.dll` and `libGLESv2.dll` and `vulkan-1.dll` to be available, possibly from your GPU vendor or ANGLE, in the `%PATH%`.
## Android Host Tests
-These are currently not built due to the dependency on system libEGL/libvulkan to run correctly.
+There are Android mock testa available, runnable on Linux. To build these tests, run:
+
+ m GfxstreamEnd2EndTests
# Structure
@@ -105,3 +90,21 @@
- `stream-servers/`: implementations of various backends for various graphics
APIs that consume protocol. `gfxstream-virtio-gpu-renderer.cpp` contains a
virtio-gpu backend implementation.
+
+# Guest Vulkan design
+
+gfxstream vulkan is the most actively developed component. Some key commponents of
+the current design include:
+
+- 1:1 threading model - each guest Vulkan encoder thread gets host side decoding thread
+- Support for both virtio-gpu, goldish and testing transports.
+- Support for Android, Fuchsia, and Linux guests.
+- Ring Buffer to stream commands, in the style of io_uring.
+- Mesa embedded to provide [dispatch](https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/docs/vulkan/dispatch.rst)
+ and [objects](https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/docs/vulkan/base-objs.rst).
+- Currently, there are a set of Mesa objects and gfxstream objects. For example,
+ `struct gfxstream_vk_device` and the gfxstream object `goldfish_device` both are internal
+ representations of Vulkan opaque handle `VkDevice`. The Mesa object is used first, since Mesa
+ provides dispatch. The Mesa object contains a key to the hash table to get a gfxstream
+ internal object (for example, `gfxstream_vk_device::internal_object`). Eventually, gfxstream
+ objects will be phased out and Mesa objects used exclusively.
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py b/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py
index 016d6ca..49408bd 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py
@@ -2,6 +2,10 @@
from .common.vulkantypes import \
VulkanAPI, makeVulkanTypeSimple, iterateVulkanType
from .common.vulkantypes import EXCLUDED_APIS
+from .common.vulkantypes import HANDLE_TYPES
+
+import copy
+import re
RESOURCE_TRACKER_ENTRIES = [
"vkEnumerateInstanceExtensionProperties",
@@ -91,13 +95,76 @@
"VkResult" : ["VK_SUCCESS"],
}
-POSTPROCESSES = {
- "vkResetCommandPool" : """if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
- }""",
- "vkAllocateCommandBuffers" : """if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->addToCommandPool(pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
- }""",
+HANDWRITTEN_ENTRY_POINTS = [
+ # Instance/device/physical-device special-handling, dispatch tables, etc..
+ "vkCreateInstance",
+ "vkDestroyInstance",
+ "vkGetInstanceProcAddr",
+ "vkEnumerateInstanceVersion",
+ "vkEnumerateInstanceLayerProperties",
+ "vkEnumerateInstanceExtensionProperties",
+ "vkEnumerateDeviceExtensionProperties",
+ "vkGetDeviceProcAddr",
+ "vkEnumeratePhysicalDevices",
+ "vkEnumeratePhysicalDeviceGroups",
+ "vkCreateDevice",
+ "vkDestroyDevice",
+ "vkCreateComputePipelines",
+ # Manual alloc/free + vk_*_init/free() call w/ special params
+ "vkGetDeviceQueue",
+ "vkGetDeviceQueue2",
+ # Command pool/buffer handling
+ "vkCreateCommandPool",
+ "vkDestroyCommandPool",
+ "vkAllocateCommandBuffers",
+ "vkResetCommandPool",
+ "vkFreeCommandBuffers",
+ "vkResetCommandPool",
+ # Special cases to handle struct translations in the pNext chain
+ # TODO: Make a codegen module (use deepcopy as reference) to make this more robust
+ "vkCmdBeginRenderPass2KHR",
+ "vkCmdBeginRenderPass",
+ "vkAllocateMemory",
+]
+
+# TODO: handles with no equivalent gfxstream objects (yet).
+# Might need some special handling.
+HANDLES_DONT_TRANSLATE = {
+ "VkSurfaceKHR",
+ ## The following objects have no need for mesa counterparts
+ # Allows removal of handwritten create/destroy (for array).
+ "VkDescriptorSet",
+ # Bug in translation
+ "VkSampler",
+ "VkSamplerYcbcrConversion",
+}
+
+# Handles whose gfxstream object have non-base-object vk_ structs
+# Optionally includes array of pairs of extraParams: {index, extraParam}
+# -1 means drop parameter of paramName specified by extraParam
+HANDLES_MESA_VK = {
+ # Handwritten handlers (added here for completeness)
+ "VkInstance" : None,
+ "VkPhysicalDevice" : None,
+ "VkDevice" : None,
+ "VkQueue" : None,
+ "VkCommandPool" : None,
+ "VkCommandBuffer" : None,
+ # Auto-generated creation/destroy
+ "VkDeviceMemory" : None,
+ "VkQueryPool" : None,
+ "VkBuffer" : [[-1, "pMemoryRequirements"]],
+ "VkBufferView" : None,
+ "VkImage" : [[-1, "pMemoryRequirements"]],
+ "VkImageView": [[1, "false /* driver_internal */"]],
+ "VkSampler" : None,
+}
+
+# Types that have a corresponding method for transforming
+# an input list to its internal counterpart
+TYPES_TRANSFORM_LIST_METHOD = {
+ "VkSemaphore",
+ "VkSemaphoreSubmitInfo",
}
def is_cmdbuf_dispatch(api):
@@ -106,6 +173,59 @@
def is_queue_dispatch(api):
return "VkQueue" == api.parameters[0].typeName
+def getCreateParam(api):
+ for param in api.parameters:
+ if param.isCreatedBy(api):
+ return param
+ return None
+
+def getDestroyParam(api):
+ for param in api.parameters:
+ if param.isDestroyedBy(api):
+ return param
+ return None
+
+# i.e. VkQueryPool --> vk_query_pool
+def typeNameToMesaType(typeName):
+ vkTypeNameRegex = "(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])"
+ words = re.split(vkTypeNameRegex, typeName)
+ outputType = "vk"
+ for word in words[1:]:
+ outputType += "_"
+ outputType += word.lower()
+ return outputType
+
+def typeNameToBaseName(typeName):
+ return typeNameToMesaType(typeName)[len("vk_"):]
+
+def paramNameToObjectName(paramName):
+ return "gfxstream_%s" % paramName
+
+def typeNameToVkObjectType(typeName):
+ return "VK_OBJECT_TYPE_%s" % typeNameToBaseName(typeName).upper()
+
+def typeNameToObjectType(typeName):
+ return "gfxstream_vk_%s" % typeNameToBaseName(typeName)
+
+def transformListFuncName(typeName):
+ return "transform%sList" % (typeName)
+
+def hasMesaVkObject(typeName):
+ return typeName in HANDLES_MESA_VK
+
+def isAllocatorParam(param):
+ ALLOCATOR_TYPE_NAME = "VkAllocationCallbacks"
+ return (param.pointerIndirectionLevels == 1
+ and param.isConst
+ and param.typeName == ALLOCATOR_TYPE_NAME)
+
+def isArrayParam(param):
+ return (1 == param.pointerIndirectionLevels
+ and param.isConst
+ and "len" in param.attribs)
+
+INTERNAL_OBJECT_NAME = "internal_object"
+
class VulkanFuncTable(VulkanWrapperGenerator):
def __init__(self, module, typeInfo):
VulkanWrapperGenerator.__init__(self, module, typeInfo)
@@ -119,11 +239,6 @@
def onBegin(self,):
cgen = self.cgen
- cgen.line("static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature)")
- cgen.beginBlock()
- cgen.stmt("ALOGE(\"invalid call to %s: %s not supported\", apiname, neededFeature)")
- cgen.stmt("abort()")
- cgen.endBlock()
self.module.appendImpl(cgen.swapCode())
pass
@@ -144,264 +259,365 @@
api = typeInfo.apis[name]
self.entries.append(api)
self.entryFeatures.append(self.feature)
+ self.loopVars = ["i", "j", "k", "l", "m", "n"]
+ self.loopVarIndex = 0
- def genEncoderOrResourceTrackerCall(cgen, api, declareResources=True):
- cgen.stmt("AEMU_SCOPED_TRACE(\"%s\")" % api.name)
+ def getNextLoopVar():
+ if self.loopVarIndex >= len(self.loopVars):
+ raise
+ loopVar = self.loopVars[self.loopVarIndex]
+ self.loopVarIndex += 1
+ return loopVar
- if is_cmdbuf_dispatch(api):
- cgen.stmt("auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer)")
- elif is_queue_dispatch(api):
- cgen.stmt("auto vkEnc = ResourceTracker::getQueueEncoder(queue)")
+ def isCompoundType(typeName):
+ return typeInfo.isCompoundType(typeName)
+
+ def handleTranslationRequired(typeName):
+ return typeName in HANDLE_TYPES and typeName not in HANDLES_DONT_TRANSLATE
+
+ def translationRequired(typeName):
+ if isCompoundType(typeName):
+ struct = typeInfo.structs[typeName]
+ for member in struct.members:
+ if translationRequired(member.typeName):
+ return True
+ return False
else:
- cgen.stmt("auto vkEnc = ResourceTracker::getThreadLocalEncoder()")
+ return handleTranslationRequired(typeName)
+
+ def genDestroyGfxstreamObjects():
+ destroyParam = getDestroyParam(api)
+ if not destroyParam:
+ return
+ if not translationRequired(destroyParam.typeName):
+ return
+ objectName = paramNameToObjectName(destroyParam.paramName)
+ allocatorParam = "NULL"
+ for p in api.parameters:
+ if isAllocatorParam(p):
+ allocatorParam = p.paramName
+ if not hasMesaVkObject(destroyParam.typeName):
+ deviceParam = api.parameters[0]
+ if "VkDevice" != deviceParam.typeName:
+ print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
+ raise
+ # call vk_object_free() directly
+ mesaObjectDestroy = "(void *)%s" % objectName
+ cgen.funcCall(
+ None,
+ "vk_object_free",
+ ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, mesaObjectDestroy]
+ )
+ else:
+ baseName = typeNameToBaseName(destroyParam.typeName)
+ # objectName for destroy always at the back
+ mesaObjectPrimary = "&%s->vk" % paramNameToObjectName(api.parameters[0].paramName)
+ mesaObjectDestroy = "&%s->vk" % objectName
+ cgen.funcCall(
+ None,
+ "vk_%s_destroy" % (baseName),
+ [mesaObjectPrimary, allocatorParam, mesaObjectDestroy]
+ )
+
+ def genMesaObjectAlloc(allocCallLhs):
+ deviceParam = api.parameters[0]
+ if "VkDevice" != deviceParam.typeName:
+ print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
+ raise
+ allocatorParam = "NULL"
+ for p in api.parameters:
+ if isAllocatorParam(p):
+ allocatorParam = p.paramName
+ createParam = getCreateParam(api)
+ objectType = typeNameToObjectType(createParam.typeName)
+ # Call vk_object_zalloc directly
+ cgen.funcCall(
+ allocCallLhs,
+ "(%s *)vk_object_zalloc" % objectType,
+ ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, ("sizeof(%s)" % objectType), typeNameToVkObjectType(createParam.typeName)]
+ )
+
+ def genMesaObjectCreate(createCallLhs):
+ def dropParam(params, drop):
+ for p in params:
+ if p == drop:
+ params.remove(p)
+ return params
+ createParam = getCreateParam(api)
+ objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
+ modParams = copy.deepcopy(api.parameters)
+ # Mod params for the vk_%s_create() call i.e. vk_buffer_create()
+ for p in modParams:
+ if p.paramName == createParam.paramName:
+ modParams.remove(p)
+ elif handleTranslationRequired(p.typeName):
+ # Cast handle to the mesa type
+ p.paramName = ("(%s*)%s" % (typeNameToMesaType(p.typeName), paramNameToObjectName(p.paramName)))
+ mesaCreateParams = [p.paramName for p in modParams] + ["sizeof(%s)" % objectType]
+ # Some special handling
+ extraParams = HANDLES_MESA_VK[createParam.typeName]
+ if extraParams:
+ for pair in extraParams:
+ if -1 == pair[0]:
+ mesaCreateParams = dropParam(mesaCreateParams, pair[1])
+ else:
+ mesaCreateParams.insert(pair[0], pair[1])
+ cgen.funcCall(
+ createCallLhs,
+ "(%s *)vk_%s_create" % (objectType, typeNameToBaseName(createParam.typeName)),
+ mesaCreateParams
+ )
+
+ # Alloc/create gfxstream_vk_* object
+ def genCreateGfxstreamObjects():
+ createParam = getCreateParam(api)
+ if not createParam:
+ return False
+ if not handleTranslationRequired(createParam.typeName):
+ return False
+ objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
+ callLhs = "%s *%s" % (objectType, paramNameToObjectName(createParam.paramName))
+ if hasMesaVkObject(createParam.typeName):
+ genMesaObjectCreate(callLhs)
+ else:
+ genMesaObjectAlloc(callLhs)
+
+ retVar = api.getRetVarExpr()
+ if retVar:
+ retTypeName = api.getRetTypeExpr()
+ # ex: vkCreateBuffer_VkResult_return = gfxstream_buffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ cgen.stmt("%s = %s ? %s : %s" %
+ (retVar, paramNameToObjectName(createParam.paramName), SUCCESS_VAL[retTypeName][0], "VK_ERROR_OUT_OF_HOST_MEMORY"))
+ return True
+
+ def genVkFromHandle(param, fromName):
+ objectName = paramNameToObjectName(param.paramName)
+ cgen.stmt("VK_FROM_HANDLE(%s, %s, %s)" %
+ (typeNameToObjectType(param.typeName), objectName, fromName))
+ return objectName
+
+ def genGetGfxstreamHandles():
+ createParam = getCreateParam(api)
+ for param in api.parameters:
+ if not handleTranslationRequired(param.typeName):
+ continue
+ elif isArrayParam(param):
+ continue
+ elif param != createParam:
+ if param.pointerIndirectionLevels > 0:
+ print("ERROR: Unhandled pointerIndirectionLevels > 1 for API %s (param %s)" % (api.name, param.paramName))
+ raise
+ genVkFromHandle(param, param.paramName)
+
+ def internalNestedParamName(param):
+ parentName = ""
+ if param.parent:
+ parentName = "_%s" % param.parent.typeName
+ return "internal%s_%s" % (parentName, param.paramName)
+
+ def genInternalArrayDeclarations(param, countParamName, nestLevel=0):
+ internalArray = None
+ if 0 == nestLevel:
+ internalArray = "internal_%s" % param.paramName
+ cgen.stmt("std::vector<%s> %s(%s)" % (param.typeName, internalArray, countParamName))
+ elif 1 == nestLevel or 2 == nestLevel:
+ internalArray = internalNestedParamName(param)
+ if isArrayParam(param):
+ cgen.stmt("std::vector<std::vector<%s>> %s" % (param.typeName, internalArray))
+ else:
+ cgen.stmt("std::vector<%s> %s" % (param.typeName, internalArray))
+ else:
+ print("ERROR: nestLevel > 2 not verified.")
+ raise
+ if isCompoundType(param.typeName):
+ for member in typeInfo.structs[param.typeName].members:
+ if translationRequired(member.typeName):
+ if handleTranslationRequired(member.typeName) and not isArrayParam(member):
+ # No declarations for non-array handleType
+ continue
+ genInternalArrayDeclarations(member, countParamName, nestLevel + 1)
+ return internalArray
+
+ def genInternalCompoundType(param, outName, inName, currLoopVar):
+ nextLoopVar = None
+ cgen.stmt("%s = %s" % (outName, inName))
+ for member in typeInfo.structs[param.typeName].members:
+ if not translationRequired(member.typeName):
+ continue
+ cgen.line("/* %s::%s */" % (param.typeName, member.paramName))
+ nestedOutName = ("%s[%s]" % (internalNestedParamName(member), currLoopVar))
+ if isArrayParam(member):
+ countParamName = "%s.%s" % (outName, member.attribs["len"])
+ inArrayName = "%s.%s" % (outName, member.paramName)
+ cgen.stmt("%s.push_back(std::vector<%s>())" % (internalNestedParamName(member), member.typeName))
+ if member.typeName in TYPES_TRANSFORM_LIST_METHOD:
+ # Use the corresponding transformList call
+ cgen.funcCall(nestedOutName, transformListFuncName(member.typeName), [inArrayName, countParamName])
+ cgen.stmt("%s = %s.data()" % (inArrayName, nestedOutName))
+ cgen.stmt("%s = %s.size()" % (countParamName, nestedOutName))
+ else:
+ # Standard translation
+ cgen.stmt("%s.reserve(%s)" % (nestedOutName, countParamName))
+ cgen.stmt("memset(&%s[0], 0, sizeof(%s) * %s)" % (nestedOutName, member.typeName, countParamName))
+ if not nextLoopVar:
+ nextLoopVar = getNextLoopVar()
+ internalArray = genInternalArray(member, countParamName, nestedOutName, inArrayName, nextLoopVar)
+ cgen.stmt("%s = %s" %(inArrayName, internalArray))
+ elif isCompoundType(member.typeName):
+ memberFullName = "%s.%s" % (outName, member.paramName)
+ if 1 == member.pointerIndirectionLevels:
+ cgen.beginIf(memberFullName)
+ inParamName = "%s[0]" % memberFullName
+ genInternalCompoundType(member, nestedOutName, inParamName, currLoopVar)
+ cgen.stmt("%s.%s = &%s" % (outName, member.paramName, nestedOutName))
+ else:
+ cgen.beginBlock()
+ genInternalCompoundType(member, nestedOutName, memberFullName, currLoopVar)
+ cgen.stmt("%s.%s = %s" % (outName, member.paramName, nestedOutName))
+ cgen.endBlock()
+ else:
+ # Replace member with internal object
+ replaceName = "%s.%s" % (outName, member.paramName)
+ if member.isOptional:
+ cgen.beginIf(replaceName)
+ gfxstreamObject = genVkFromHandle(member, replaceName)
+ cgen.stmt("%s = %s->%s" % (replaceName, gfxstreamObject, INTERNAL_OBJECT_NAME))
+ if member.isOptional:
+ cgen.endIf()
+
+ def genInternalArray(param, countParamName, outArrayName, inArrayName, loopVar):
+ cgen.beginFor("uint32_t %s = 0" % loopVar, "%s < %s" % (loopVar, countParamName), "++%s" % loopVar)
+ if param.isOptional:
+ cgen.beginIf(inArrayName)
+ if isCompoundType(param.typeName):
+ genInternalCompoundType(param, ("%s[%s]" % (outArrayName, loopVar)), "%s[%s]" % (inArrayName, loopVar), loopVar)
+ else:
+ gfxstreamObject = genVkFromHandle(param, "%s[%s]" % (inArrayName, loopVar))
+ cgen.stmt("%s[%s] = %s->%s" % (outArrayName, loopVar, gfxstreamObject, INTERNAL_OBJECT_NAME))
+ if param.isOptional:
+ cgen.endIf()
+ cgen.endFor()
+ return "%s.data()" % outArrayName
+
+ # Translate params into params needed for gfxstream-internal
+ # encoder/resource-tracker calls
+ def getEncoderOrResourceTrackerParams():
+ createParam = getCreateParam(api)
+ outParams = copy.deepcopy(api.parameters)
+ nextLoopVar = getNextLoopVar()
+ for param in outParams:
+ if not translationRequired(param.typeName):
+ continue
+ elif isArrayParam(param) or isCompoundType(param.typeName):
+ if param.possiblyOutput():
+ print("ERROR: Unhandled CompoundType / Array output for API %s (param %s)" % (api.name, param.paramName))
+ raise
+ if 1 != param.pointerIndirectionLevels or not param.isConst:
+ print("ERROR: Compound type / array input is not 'const <type>*' (API: %s, paramName: %s)" % (api.name, param.paramName))
+ raise
+ countParamName = "1"
+ if "len" in param.attribs:
+ countParamName = param.attribs["len"]
+ internalArrayName = genInternalArrayDeclarations(param, countParamName)
+ param.paramName = genInternalArray(param, countParamName, internalArrayName, param.paramName, nextLoopVar)
+ elif 0 == param.pointerIndirectionLevels:
+ if param.isOptional:
+ param.paramName = ("%s ? %s->%s : VK_NULL_HANDLE" % (paramNameToObjectName(param.paramName), paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
+ else:
+ param.paramName = ("%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
+ elif createParam and param.paramName == createParam.paramName:
+ param.paramName = ("&%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
+ else:
+ print("ERROR: Unknown handling for param: %s (API: %s)" % (param, api.name))
+ raise
+ return outParams
+
+ def genEncoderOrResourceTrackerCall(declareResources=True):
+ if is_cmdbuf_dispatch(api):
+ cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
+ elif is_queue_dispatch(api):
+ cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getQueueEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
+ else:
+ cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder()")
callLhs = None
retTypeName = api.getRetTypeExpr()
if retTypeName != "void":
- retVar = api.getRetVarExpr()
- cgen.stmt("%s %s = (%s)0" % (retTypeName, retVar, retTypeName))
- callLhs = retVar
+ callLhs = api.getRetVarExpr()
+ # Get parameter list modded for gfxstream-internal call
+ parameters = getEncoderOrResourceTrackerParams()
if name in RESOURCE_TRACKER_ENTRIES:
if declareResources:
- cgen.stmt("auto resources = ResourceTracker::get()")
+ cgen.stmt("auto resources = gfxstream::vk::ResourceTracker::get()")
cgen.funcCall(
callLhs, "resources->" + "on_" + api.name,
["vkEnc"] + SUCCESS_VAL.get(retTypeName, []) + \
- [p.paramName for p in api.parameters])
+ [p.paramName for p in parameters])
else:
cgen.funcCall(
- callLhs, "vkEnc->" + api.name, [p.paramName for p in api.parameters] + ["true /* do lock */"])
+ callLhs, "vkEnc->" + api.name, [p.paramName for p in parameters] + ["true /* do lock */"])
- if name in POSTPROCESSES:
- cgen.line(POSTPROCESSES[name])
+ def genReturnExpression():
+ retTypeName = api.getRetTypeExpr()
+ # Set the createParam output, if applicable
+ createParam = getCreateParam(api)
+ if createParam and handleTranslationRequired(createParam.typeName):
+ if 1 != createParam.pointerIndirectionLevels:
+ print("ERROR: Unhandled pointerIndirectionLevels != 1 in return for API %s (createParam %s)" % api.name, createParam.paramName)
+ raise
+ # ex: *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_buffer)
+ cgen.funcCall(
+ "*%s" % createParam.paramName,
+ "%s_to_handle" % typeNameToObjectType(createParam.typeName),
+ [paramNameToObjectName(createParam.paramName)]
+ )
if retTypeName != "void":
- cgen.stmt("return %s" % retVar)
+ cgen.stmt("return %s" % api.getRetVarExpr())
-
- api_entry = api.withModifiedName("entry_" + api.name)
-
- cgen.line("static " + self.cgen.makeFuncProto(api_entry))
- cgen.beginBlock()
- genEncoderOrResourceTrackerCall(cgen, api)
- cgen.endBlock()
-
- if self.isDeviceDispatch(api) and self.feature != "VK_VERSION_1_0":
- api_entry_dyn_check = api.withModifiedName("dynCheck_entry_" + api.name)
- cgen.line("static " + self.cgen.makeFuncProto(api_entry_dyn_check))
- cgen.beginBlock()
- if self.feature == "VK_VERSION_1_3":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer)")
- cgen.beginIf("resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3")
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
+ def genGfxstreamEntry(declareResources=True):
+ cgen.stmt("AEMU_SCOPED_TRACE(\"%s\")" % api.name)
+ # declare returnVar
+ retTypeName = api.getRetTypeExpr()
+ retVar = api.getRetVarExpr()
+ if retVar:
+ cgen.stmt("%s %s = (%s)0" % (retTypeName, retVar, retTypeName))
+ # Check non-null destroy param for free/destroy calls
+ destroyParam = getDestroyParam(api)
+ if destroyParam:
+ cgen.beginIf("VK_NULL_HANDLE == %s" % destroyParam.paramName)
+ if api.getRetTypeExpr() != "void":
+ cgen.stmt("return %s" % api.getRetVarExpr())
+ else:
+ cgen.stmt("return")
cgen.endIf()
- elif self.feature == "VK_VERSION_1_2":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer)")
- cgen.beginIf("resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2")
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
- cgen.endIf()
- elif self.feature == "VK_VERSION_1_1":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer)")
- cgen.beginIf("resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1")
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
- cgen.endIf()
- elif self.feature != "VK_VERSION_1_0":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer);")
- cgen.beginIf("!resources->hasDeviceExtension(device, \"%s\")" % self.feature)
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
- cgen.endIf()
+ # Translate handles
+ genGetGfxstreamHandles()
+ # Translation/creation of objects
+ createdObject = genCreateGfxstreamObjects()
+ # Make encoder/resource-tracker call
+ if retVar and createdObject:
+ cgen.beginIf("%s == %s" % (SUCCESS_VAL[retTypeName][0], retVar))
else:
- print("About to generate a frivolous api!: dynCheck entry: %s" % api.name)
- raise
- genEncoderOrResourceTrackerCall(cgen, api, declareResources = False)
+ cgen.beginBlock()
+ genEncoderOrResourceTrackerCall()
cgen.endBlock()
+ # Destroy gfxstream objects
+ genDestroyGfxstreamObjects()
+ # Set output / return variables
+ genReturnExpression()
- self.module.appendImpl(cgen.swapCode())
+ api_entry = api.withModifiedName("gfxstream_vk_" + api.name[2:])
+ if api.name not in HANDWRITTEN_ENTRY_POINTS:
+ cgen.line(self.cgen.makeFuncProto(api_entry))
+ cgen.beginBlock()
+ genGfxstreamEntry()
+ cgen.endBlock()
+ self.module.appendImpl(cgen.swapCode())
+
def onEnd(self,):
- getProcAddressDecl = "void* goldfish_vulkan_get_proc_address(const char* name)"
- self.module.appendHeader(getProcAddressDecl + ";\n")
- self.module.appendImpl(getProcAddressDecl)
- self.cgen.beginBlock()
-
- prevFeature = None
- for e, f in zip(self.entries, self.entryFeatures):
- featureEndif = prevFeature is not None and (f != prevFeature)
- featureif = not featureEndif and (f != prevFeature)
-
- if featureEndif:
- self.cgen.leftline("#endif")
- self.cgen.leftline("#ifdef %s" % f)
-
- if featureif:
- self.cgen.leftline("#ifdef %s" % f)
-
- self.cgen.beginIf("!strcmp(name, \"%s\")" % e.name)
- if e.name in EXCLUDED_APIS:
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_3":
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_2":
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_1":
- self.cgen.stmt("return nullptr")
- elif f != "VK_VERSION_1_0":
- self.cgen.stmt("return nullptr")
- else:
- self.cgen.stmt("return (void*)%s" % ("entry_" + e.name))
- self.cgen.endIf()
- prevFeature = f
-
- self.cgen.leftline("#endif")
-
- self.cgen.stmt("return nullptr")
- self.cgen.endBlock()
- self.module.appendImpl(self.cgen.swapCode())
-
- getInstanceProcAddressDecl = "void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name)"
- self.module.appendHeader(getInstanceProcAddressDecl + ";\n")
- self.module.appendImpl(getInstanceProcAddressDecl)
- self.cgen.beginBlock()
-
- self.cgen.stmt(
- "auto resources = ResourceTracker::get()")
- self.cgen.stmt(
- "bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1")
- self.cgen.stmt(
- "bool has1_2OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_2")
- self.cgen.stmt(
- "bool has1_3OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_3")
-
- prevFeature = None
- for e, f in zip(self.entries, self.entryFeatures):
- featureEndif = prevFeature is not None and (f != prevFeature)
- featureif = not featureEndif and (f != prevFeature)
-
- if featureEndif:
- self.cgen.leftline("#endif")
- self.cgen.leftline("#ifdef %s" % f)
-
- if featureif:
- self.cgen.leftline("#ifdef %s" % f)
-
- self.cgen.beginIf("!strcmp(name, \"%s\")" % e.name)
-
- entryPointExpr = "(void*)%s" % ("entry_" + e.name)
-
- if e.name in EXCLUDED_APIS:
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_3":
- if self.isDeviceDispatch(e):
- self.cgen.stmt("return (void*)dynCheck_entry_%s" % e.name)
- else:
- self.cgen.stmt( \
- "return has1_3OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_2":
- if self.isDeviceDispatch(e):
- self.cgen.stmt("return (void*)dynCheck_entry_%s" % e.name)
- else:
- self.cgen.stmt( \
- "return has1_2OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_1":
- if self.isDeviceDispatch(e):
- self.cgen.stmt("return (void*)dynCheck_entry_%s" % e.name)
- else:
- self.cgen.stmt( \
- "return has1_1OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f != "VK_VERSION_1_0":
- entryNeedsInstanceExtensionCheck = self.cmdToFeatureType[e.name] == "instance"
-
- entryPrefix = "dynCheck_" if self.isDeviceDispatch(e) else ""
- entryPointExpr = "(void*)%sentry_%s" % (entryPrefix, e.name)
-
- if entryNeedsInstanceExtensionCheck:
- self.cgen.stmt("bool hasExt = resources->hasInstanceExtension(instance, \"%s\")" % f)
- self.cgen.stmt("return hasExt ? %s : nullptr" % entryPointExpr)
- else:
- # TODO(b/236246382): We need to check the device extension support here.
- self.cgen.stmt("// TODO(b/236246382): Check support for device extension");
- self.cgen.stmt("return %s" % entryPointExpr)
-
- else:
- self.cgen.stmt("return %s" % entryPointExpr)
- self.cgen.endIf()
- prevFeature = f
-
- self.cgen.leftline("#endif")
-
- self.cgen.stmt("return nullptr")
- self.cgen.endBlock()
- self.module.appendImpl(self.cgen.swapCode())
-
- getDeviceProcAddressDecl = "void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name)"
- self.module.appendHeader(getDeviceProcAddressDecl + ";\n")
- self.module.appendImpl(getDeviceProcAddressDecl)
- self.cgen.beginBlock()
-
- self.cgen.stmt(
- "auto resources = ResourceTracker::get()")
- self.cgen.stmt(
- "bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1")
- self.cgen.stmt(
- "bool has1_2OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_2")
- self.cgen.stmt(
- "bool has1_3OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_3")
- prevFeature = None
- for e, f in zip(self.entries, self.entryFeatures):
- featureEndif = prevFeature is not None and (f != prevFeature)
- featureif = not featureEndif and (f != prevFeature)
-
- if featureEndif:
- self.cgen.leftline("#endif")
- self.cgen.leftline("#ifdef %s" % f)
-
- if featureif:
- self.cgen.leftline("#ifdef %s" % f)
-
- self.cgen.beginIf("!strcmp(name, \"%s\")" % e.name)
-
- entryPointExpr = "(void*)%s" % ("entry_" + e.name)
-
- if e.name in EXCLUDED_APIS:
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_3":
- self.cgen.stmt( \
- "return has1_3OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_2":
- self.cgen.stmt( \
- "return has1_2OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_1":
- self.cgen.stmt( \
- "return has1_1OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f != "VK_VERSION_1_0":
- self.cgen.stmt( \
- "bool hasExt = resources->hasDeviceExtension(device, \"%s\")" % f)
- self.cgen.stmt("return hasExt ? %s : nullptr" % entryPointExpr)
- else:
- self.cgen.stmt("return %s" % entryPointExpr)
- self.cgen.endIf()
- prevFeature = f
-
- self.cgen.leftline("#endif")
-
- self.cgen.stmt("return nullptr")
- self.cgen.endBlock()
-
- self.module.appendImpl(self.cgen.swapCode())
+ pass
def isDeviceDispatch(self, api):
# TODO(230793667): improve the heuristic and just use "cmdToFeatureType"
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
index 6a8de36..886df53 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
@@ -77,6 +77,7 @@
"VK_KHR_create_renderpass2",
"VK_KHR_imageless_framebuffer",
"VK_KHR_descriptor_update_template",
+ "VK_EXT_depth_clip_enable",
# see aosp/2736079 + b/268351352
"VK_EXT_swapchain_maintenance1",
"VK_KHR_maintenance5",
@@ -128,6 +129,8 @@
"VK_EXT_graphics_pipeline_library",
# Used by guest ANGLE
"VK_EXT_vertex_attribute_divisor",
+ # QNX
+ "VK_QNX_external_memory_screen_buffer",
]
HOST_MODULES = ["goldfish_vk_extension_structs", "goldfish_vk_marshaling",
@@ -151,6 +154,7 @@
"VK_KHR_external_semaphore_win32" : ["goldfish_vk_dispatch"],
"VK_KHR_external_memory_win32" : ["goldfish_vk_dispatch"],
"VK_KHR_external_memory_fd": ["goldfish_vk_dispatch"],
+ "VK_QNX_external_memory_screen_buffer": ["goldfish_vk_dispatch"],
"VK_ANDROID_external_memory_android_hardware_buffer": ["func_table"],
"VK_KHR_android_surface": ["func_table"],
"VK_EXT_swapchain_maintenance1" : HOST_MODULES,
@@ -343,6 +347,8 @@
#include "VkEncoder.h"
#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
+#include "gfxstream_vk_entrypoints.h"
+#include "gfxstream_vk_private.h"
#include "goldfish_vk_private_defs.h"
@@ -603,7 +609,8 @@
suppressVulkanHeaders=True,
extraHeader=createVkExtensionStructureTypePreamble('VK_GOOGLE_GFXSTREAM'))
- self.addGuestEncoderModule("func_table", extraImpl=functableImplInclude)
+ self.addGuestEncoderModule("func_table", extraImpl=functableImplInclude, implOnly = True,
+ useNamespace = False)
self.addCppModule("common", "goldfish_vk_extension_structs",
extraHeader=extensionStructsInclude)
@@ -695,13 +702,13 @@
def addGuestEncoderModule(
self, basename, extraHeader="", extraImpl="", useNamespace=True, headerOnly=False,
- suppressFeatureGuards=False, moduleName=None, suppressVulkanHeaders=False):
+ suppressFeatureGuards=False, moduleName=None, suppressVulkanHeaders=False, implOnly=False):
if not os.path.exists(self.guest_abs_encoder_destination):
print("Path [%s] not found (guest encoder path), skipping" % self.guest_abs_encoder_destination)
return
self.addCppModule(self.guest_encoder_tag, basename, extraHeader=extraHeader,
extraImpl=extraImpl, customAbsDir=self.guest_abs_encoder_destination,
- useNamespace=useNamespace, headerOnly=headerOnly,
+ useNamespace=useNamespace, implOnly=implOnly, headerOnly=headerOnly,
suppressFeatureGuards=suppressFeatureGuards, moduleName=moduleName,
suppressVulkanHeaders=suppressVulkanHeaders)
diff --git a/codegen/vulkan/vulkan-docs-next/xml/vk.xml b/codegen/vulkan/vulkan-docs-next/xml/vk.xml
index 3d8405a..11e244d 100644
--- a/codegen/vulkan/vulkan-docs-next/xml/vk.xml
+++ b/codegen/vulkan/vulkan-docs-next/xml/vk.xml
@@ -13041,8 +13041,8 @@
<param><type>VkDevice</type> <name>device</name></param>
<param><type>VkImage</type> <name>image</name></param>
<param><type>int</type> <name>nativeFenceFd</name></param>
- <param><type>VkSemaphore</type> <name>semaphore</name></param>
- <param><type>VkFence</type> <name>fence</name></param>
+ <param optional="true"><type>VkSemaphore</type> <name>semaphore</name></param>
+ <param optional="true"><type>VkFence</type> <name>fence</name></param>
</command>
<command>
<proto><type>VkResult</type> <name>vkQueueSignalReleaseImageANDROID</name></proto>
diff --git a/common/end2end/Android.bp b/common/end2end/Android.bp
index 57a0754..cf2cbdf 100644
--- a/common/end2end/Android.bp
+++ b/common/end2end/Android.bp
@@ -21,7 +21,6 @@
"libGLESv1_CM_emulation_with_host",
"libGLESv2_emulation_with_host",
"libEGL_emulation_with_host",
- "libgfxstream_guest_vulkan_encoder_with_host",
"libgfxstream_guest_vulkan_with_host",
],
shared_libs: [
@@ -29,6 +28,7 @@
"libdrm",
"liblog",
"libgfxstream_backend",
+ "libplatform_rutabaga",
"libOpenglSystemCommonWithHost",
],
static_libs: [
@@ -39,7 +39,6 @@
"libc++fs",
"libgmock",
"liblz4",
- "libplatform_rutabaga",
],
cflags: [
// TODO: remove
diff --git a/common/end2end/GfxstreamEnd2EndTests.cpp b/common/end2end/GfxstreamEnd2EndTests.cpp
index f9b04a4..7cc7999 100644
--- a/common/end2end/GfxstreamEnd2EndTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndTests.cpp
@@ -23,21 +23,16 @@
#include <log/log.h>
#include "aemu/base/system/System.h"
-#include "drm_fourcc.h"
-#include "Gralloc.h"
#include "gfxstream/RutabagaLayerTestUtils.h"
-#include "host-common/GfxstreamFatalError.h"
#include "host-common/logging.h"
#include "ProcessPipe.h"
-#include "virgl_hw.h"
+#include "drm_fourcc.h"
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
namespace gfxstream {
namespace tests {
-using emugl::ABORT_REASON_OTHER;
-using emugl::FatalError;
using testing::AnyOf;
using testing::Eq;
using testing::Gt;
@@ -45,310 +40,6 @@
using testing::Not;
using testing::NotNull;
-std::optional<uint32_t> GlFormatToDrmFormat(uint32_t glFormat) {
- switch (glFormat) {
- case GL_RGB:
- return DRM_FORMAT_BGR888;
- case GL_RGB565:
- return DRM_FORMAT_BGR565;
- case GL_RGBA:
- return DRM_FORMAT_ABGR8888;
- }
- return std::nullopt;
-}
-
-TestingAHardwareBuffer::TestingAHardwareBuffer(
- uint32_t width,
- uint32_t height,
- VirtGpuBlobPtr resource)
- : mWidth(width),
- mHeight(height),
- mResource(resource) {}
-
-uint32_t TestingAHardwareBuffer::getResourceId() const {
- return mResource->getResourceHandle();
-}
-
-uint32_t TestingAHardwareBuffer::getWidth() const {
- return mWidth;
-}
-
-uint32_t TestingAHardwareBuffer::getHeight() const {
- return mHeight;
-}
-
-int TestingAHardwareBuffer::getAndroidFormat() const {
- return /*AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM=*/1;
-}
-
-uint32_t TestingAHardwareBuffer::getDrmFormat() const {
- return DRM_FORMAT_ABGR8888;
-}
-
-AHardwareBuffer* TestingAHardwareBuffer::asAHardwareBuffer() {
- return reinterpret_cast<AHardwareBuffer*>(this);
-}
-
-buffer_handle_t TestingAHardwareBuffer::asBufferHandle() {
- return reinterpret_cast<buffer_handle_t>(this);
-}
-
-EGLClientBuffer TestingAHardwareBuffer::asEglClientBuffer() {
- return reinterpret_cast<EGLClientBuffer>(this);
-}
-
-TestingVirtGpuGralloc::TestingVirtGpuGralloc() {}
-
-uint32_t TestingVirtGpuGralloc::createColorBuffer(
- void*,
- int width,
- int height,
- uint32_t glFormat) {
- auto drmFormat = GlFormatToDrmFormat(glFormat);
- if (!drmFormat) {
- GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Unhandled format:" << glFormat;
- }
-
- auto ahb = allocate(width, height, *drmFormat);
-
- uint32_t hostHandle = ahb->getResourceId();
- mAllocatedColorBuffers.emplace(hostHandle, std::move(ahb));
- return hostHandle;
-}
-
-int TestingVirtGpuGralloc::allocate(
- uint32_t width,
- uint32_t height,
- uint32_t format,
- uint64_t usage,
- AHardwareBuffer** outputAhb) {
- (void)width;
- (void)height;
- (void)format;
- (void)usage;
- (void)outputAhb;
-
- // TODO: support export flow?
- GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Unimplemented.";
-
- return 0;
-}
-
-std::unique_ptr<TestingAHardwareBuffer> TestingVirtGpuGralloc::allocate(
- uint32_t width,
- uint32_t height,
- uint32_t format) {
- ALOGV("Allocating AHB w:%" PRIu32 " h:%" PRIu32 " f:%" PRIu32, width, height, format);
-
- auto device = VirtGpuDevice::getInstance();
- if (!device) {
- ALOGE("Failed to allocate: no virtio gpu device.");
- return nullptr;
- }
-
- auto resource = device->createPipeTexture2D(width, height, format);
- if (!resource) {
- ALOGE("Failed to allocate: failed to create virtio resource.");
- return nullptr;
- }
-
- resource->wait();
-
- return std::make_unique<TestingAHardwareBuffer>(width, height, std::move(resource));
-}
-
-void TestingVirtGpuGralloc::acquire(AHardwareBuffer* ahb) {
- // TODO
-}
-
-void TestingVirtGpuGralloc::release(AHardwareBuffer* ahb) {
- // TODO
-}
-
-uint32_t TestingVirtGpuGralloc::getHostHandle(const native_handle_t* handle) {
- const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
- return ahb->getResourceId();
-}
-
-uint32_t TestingVirtGpuGralloc::getHostHandle(const AHardwareBuffer* handle) {
- const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
- return ahb->getResourceId();
-}
-
-int TestingVirtGpuGralloc::getFormat(const native_handle_t* handle) {
- const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
- return ahb->getAndroidFormat();
-}
-
-int TestingVirtGpuGralloc::getFormat(const AHardwareBuffer* handle) {
- const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
- return ahb->getAndroidFormat();
-}
-
-uint32_t TestingVirtGpuGralloc::getFormatDrmFourcc(const AHardwareBuffer* handle) {
- const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
- return ahb->getDrmFormat();
-}
-
-size_t TestingVirtGpuGralloc::getAllocatedSize(const native_handle_t*) {
- GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Unimplemented.";
- return 0;
-}
-
-size_t TestingVirtGpuGralloc::getAllocatedSize(const AHardwareBuffer*) {
- GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Unimplemented.";
- return 0;
-}
-
-TestingANativeWindow::TestingANativeWindow(
- uint32_t width,
- uint32_t height,
- uint32_t format,
- std::vector<std::unique_ptr<TestingAHardwareBuffer>> buffers)
- : mWidth(width),
- mHeight(height),
- mFormat(format),
- mBuffers(std::move(buffers)) {
- for (auto& buffer : mBuffers) {
- mBufferQueue.push_back(QueuedAHB{
- .ahb = buffer.get(),
- .fence = -1,
- });
- }
-}
-
-EGLNativeWindowType TestingANativeWindow::asEglNativeWindowType() {
- return reinterpret_cast<EGLNativeWindowType>(this);
-}
-
-uint32_t TestingANativeWindow::getWidth() const {
- return mWidth;
-}
-
-uint32_t TestingANativeWindow::getHeight() const {
- return mHeight;
-}
-
-int TestingANativeWindow::getFormat() const {
- return mFormat;
-}
-
-int TestingANativeWindow::queueBuffer(EGLClientBuffer buffer, int fence) {
- auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
-
- mBufferQueue.push_back(QueuedAHB{
- .ahb = ahb,
- .fence = fence,
- });
-
- return 0;
-}
-
-int TestingANativeWindow::dequeueBuffer(EGLClientBuffer* buffer, int* fence) {
- auto queuedAhb = mBufferQueue.front();
- mBufferQueue.pop_front();
-
- *buffer = queuedAhb.ahb->asEglClientBuffer();
- *fence = queuedAhb.fence;
- return 0;
-}
-
-int TestingANativeWindow::cancelBuffer(EGLClientBuffer buffer) {
- auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
-
- mBufferQueue.push_back(QueuedAHB{
- .ahb = ahb,
- .fence = -1,
- });
-
- return 0;
-}
-
-bool TestingVirtGpuANativeWindowHelper::isValid(EGLNativeWindowType window) {
- // TODO: maybe a registry of valid TestingANativeWindow-s?
- return true;
-}
-
-bool TestingVirtGpuANativeWindowHelper::isValid(EGLClientBuffer buffer) {
- // TODO: maybe a registry of valid TestingAHardwareBuffer-s?
- return true;
-}
-
-void TestingVirtGpuANativeWindowHelper::acquire(EGLNativeWindowType window) {
- // TODO: maybe a registry of valid TestingANativeWindow-s?
-}
-
-void TestingVirtGpuANativeWindowHelper::release(EGLNativeWindowType window) {
- // TODO: maybe a registry of valid TestingANativeWindow-s?
-}
-
-void TestingVirtGpuANativeWindowHelper::acquire(EGLClientBuffer buffer) {
- // TODO: maybe a registry of valid TestingAHardwareBuffer-s?
-}
-
-void TestingVirtGpuANativeWindowHelper::release(EGLClientBuffer buffer) {
- // TODO: maybe a registry of valid TestingAHardwareBuffer-s?
-}
-
-int TestingVirtGpuANativeWindowHelper::getConsumerUsage(EGLNativeWindowType window, int* usage) {
- (void)window;
- (void)usage;
- return 0;
-}
-void TestingVirtGpuANativeWindowHelper::setUsage(EGLNativeWindowType window, int usage) {
- (void)window;
- (void)usage;
-}
-
-int TestingVirtGpuANativeWindowHelper::getWidth(EGLNativeWindowType window) {
- auto anw = reinterpret_cast<TestingANativeWindow*>(window);
- return anw->getWidth();
-}
-
-int TestingVirtGpuANativeWindowHelper::getHeight(EGLNativeWindowType window) {
- auto anw = reinterpret_cast<TestingANativeWindow*>(window);
- return anw->getHeight();
-}
-
-int TestingVirtGpuANativeWindowHelper::getWidth(EGLClientBuffer buffer) {
- auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
- return ahb->getWidth();
-}
-
-int TestingVirtGpuANativeWindowHelper::getHeight(EGLClientBuffer buffer) {
- auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
- return ahb->getHeight();
-}
-
-int TestingVirtGpuANativeWindowHelper::getFormat(EGLClientBuffer buffer, Gralloc* helper) {
- auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
- return ahb->getAndroidFormat();
-}
-
-void TestingVirtGpuANativeWindowHelper::setSwapInterval(EGLNativeWindowType window, int interval) {
- GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Unimplemented.";
-}
-
-int TestingVirtGpuANativeWindowHelper::queueBuffer(EGLNativeWindowType window, EGLClientBuffer buffer, int fence) {
- auto anw = reinterpret_cast<TestingANativeWindow*>(window);
- return anw->queueBuffer(buffer, fence);
-}
-
-int TestingVirtGpuANativeWindowHelper::dequeueBuffer(EGLNativeWindowType window, EGLClientBuffer* buffer, int* fence) {
- auto anw = reinterpret_cast<TestingANativeWindow*>(window);
- return anw->dequeueBuffer(buffer, fence);
-}
-
-int TestingVirtGpuANativeWindowHelper::cancelBuffer(EGLNativeWindowType window, EGLClientBuffer buffer) {
- auto anw = reinterpret_cast<TestingANativeWindow*>(window);
- return anw->cancelBuffer(buffer);
-}
-
-int TestingVirtGpuANativeWindowHelper::getHostHandle(EGLClientBuffer buffer, Gralloc*) {
- auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
- return ahb->getResourceId();
-}
-
std::string GfxstreamTransportToEnvVar(GfxstreamTransport transport) {
switch (transport) {
case GfxstreamTransport::kVirtioGpuAsg: {
diff --git a/common/end2end/GfxstreamEnd2EndTests.h b/common/end2end/GfxstreamEnd2EndTests.h
index 05be997..36378cb 100644
--- a/common/end2end/GfxstreamEnd2EndTests.h
+++ b/common/end2end/GfxstreamEnd2EndTests.h
@@ -15,11 +15,8 @@
#include <future>
#include <inttypes.h>
#include <memory>
-#include <optional>
-#include <queue>
#include <string>
#include <thread>
-#include <unordered_map>
#include <variant>
#include <gmock/gmock.h>
@@ -46,6 +43,7 @@
#include <android-base/expected.h>
#include "HostConnection.h"
+#include "TestingAndroidWsi.h"
namespace gfxstream {
namespace tests {
@@ -144,134 +142,6 @@
std::move(vkhpp_result_value.value); \
})
-class TestingAHardwareBuffer {
- public:
- TestingAHardwareBuffer(uint32_t width,
- uint32_t height,
- VirtGpuBlobPtr resource);
-
- uint32_t getResourceId() const;
-
- uint32_t getWidth() const;
-
- uint32_t getHeight() const;
-
- int getAndroidFormat() const;
-
- uint32_t getDrmFormat() const;
-
- AHardwareBuffer* asAHardwareBuffer();
-
- buffer_handle_t asBufferHandle();
-
- EGLClientBuffer asEglClientBuffer();
-
- private:
- uint32_t mWidth;
- uint32_t mHeight;
- VirtGpuBlobPtr mResource;
-};
-
-class TestingVirtGpuGralloc : public Gralloc {
- public:
- TestingVirtGpuGralloc();
-
- uint32_t createColorBuffer(void*,
- int width,
- int height,
- uint32_t glFormat) override;
-
- int allocate(uint32_t width,
- uint32_t height,
- uint32_t format,
- uint64_t usage,
- AHardwareBuffer** outputAhb) override;
-
- std::unique_ptr<TestingAHardwareBuffer> allocate(uint32_t width,
- uint32_t height,
- uint32_t format);
-
- void acquire(AHardwareBuffer* ahb) override;
- void release(AHardwareBuffer* ahb) override;
-
- uint32_t getHostHandle(const native_handle_t* handle) override;
- uint32_t getHostHandle(const AHardwareBuffer* handle) override;
-
- int getFormat(const native_handle_t* handle) override;
- int getFormat(const AHardwareBuffer* handle) override;
-
- uint32_t getFormatDrmFourcc(const AHardwareBuffer* handle) override;
-
- size_t getAllocatedSize(const native_handle_t*) override;
- size_t getAllocatedSize(const AHardwareBuffer*) override;
-
- private:
- std::unordered_map<uint32_t, std::unique_ptr<TestingAHardwareBuffer>> mAllocatedColorBuffers;
-};
-
-class TestingANativeWindow {
- public:
- TestingANativeWindow(uint32_t width,
- uint32_t height,
- uint32_t format,
- std::vector<std::unique_ptr<TestingAHardwareBuffer>> buffers);
-
- EGLNativeWindowType asEglNativeWindowType();
-
- uint32_t getWidth() const;
-
- uint32_t getHeight() const;
-
- int getFormat() const;
-
- int queueBuffer(EGLClientBuffer buffer, int fence);
- int dequeueBuffer(EGLClientBuffer* buffer, int* fence);
- int cancelBuffer(EGLClientBuffer buffer);
-
- private:
- uint32_t mWidth;
- uint32_t mHeight;
- uint32_t mFormat;
- std::vector<std::unique_ptr<TestingAHardwareBuffer>> mBuffers;
-
- struct QueuedAHB {
- TestingAHardwareBuffer* ahb;
- int fence = -1;
- };
- std::deque<QueuedAHB> mBufferQueue;
-};
-
-class TestingVirtGpuANativeWindowHelper : public ANativeWindowHelper {
- public:
- bool isValid(EGLNativeWindowType window) override;
- bool isValid(EGLClientBuffer buffer) override;
-
- void acquire(EGLNativeWindowType window) override;
- void release(EGLNativeWindowType window) override;
-
- void acquire(EGLClientBuffer buffer) override;
- void release(EGLClientBuffer buffer) override;
-
- int getConsumerUsage(EGLNativeWindowType window, int* usage) override;
- void setUsage(EGLNativeWindowType window, int usage) override;
-
- int getWidth(EGLNativeWindowType window) override;
- int getHeight(EGLNativeWindowType window) override;
-
- int getWidth(EGLClientBuffer buffer) override;
- int getHeight(EGLClientBuffer buffer) override;
-
- int getFormat(EGLClientBuffer buffer, Gralloc* helper) override;
-
- void setSwapInterval(EGLNativeWindowType window, int interval) override;
-
- int queueBuffer(EGLNativeWindowType window, EGLClientBuffer buffer, int fence) override;
- int dequeueBuffer(EGLNativeWindowType window, EGLClientBuffer* buffer, int* fence) override;
- int cancelBuffer(EGLNativeWindowType window, EGLClientBuffer buffer) override;
-
- int getHostHandle(EGLClientBuffer buffer, Gralloc*) override;
-};
-
enum class GfxstreamTransport {
kVirtioGpuAsg,
kVirtioGpuPipe,
diff --git a/guest/Android.bp b/guest/Android.bp
index 066574b..5c406cf 100644
--- a/guest/Android.bp
+++ b/guest/Android.bp
@@ -25,5 +25,7 @@
"-DGFXSTREAM",
"-DVK_GFXSTREAM_STRUCTURE_TYPE_EXT",
"-DPLATFORM_SDK_VERSION=29",
+ "-Wno-missing-field-initializers",
+ "-Wno-unused-parameter",
],
}
diff --git a/guest/GLESv2/Android.bp b/guest/GLESv2/Android.bp
index 65b74b5..c80c148 100644
--- a/guest/GLESv2/Android.bp
+++ b/guest/GLESv2/Android.bp
@@ -72,4 +72,4 @@
compile_multilib: "64",
},
},
-}
\ No newline at end of file
+}
diff --git a/guest/GoldfishAddressSpace/Android.bp b/guest/GoldfishAddressSpace/Android.bp
index b17be93..8ea4aa7 100644
--- a/guest/GoldfishAddressSpace/Android.bp
+++ b/guest/GoldfishAddressSpace/Android.bp
@@ -15,11 +15,11 @@
"libgfxstream_guest_iostream",
],
shared_libs: [
- "libandroidemu",
"libdrm",
"liblog",
],
static_libs: [
+ "libandroidemu_static",
"libplatform",
],
export_include_dirs: [
diff --git a/guest/OpenglCodecCommon/Android.bp b/guest/OpenglCodecCommon/Android.bp
index c9b4735..1215b89 100644
--- a/guest/OpenglCodecCommon/Android.bp
+++ b/guest/OpenglCodecCommon/Android.bp
@@ -44,18 +44,20 @@
"gfxstream_opengl_headers",
],
shared_libs: [
- "libandroidemu",
"libcutils",
"liblog",
"libutils",
],
export_shared_lib_headers: [
- "libandroidemu",
"libcutils",
"liblog",
],
+ export_static_lib_headers: [
+ "libandroidemu_static",
+ ],
static_libs: [
"libgfxstream_etc",
+ "libandroidemu_static",
"libqemupipe.ranchu",
],
cflags: [
@@ -76,4 +78,4 @@
export_include_dirs: [
"include",
],
-}
\ No newline at end of file
+}
diff --git a/guest/OpenglSystemCommon/Android.bp b/guest/OpenglSystemCommon/Android.bp
index 17e3e0a..81b6240 100644
--- a/guest/OpenglSystemCommon/Android.bp
+++ b/guest/OpenglSystemCommon/Android.bp
@@ -48,7 +48,7 @@
"-DVIRTIO_GPU",
],
export_include_dirs: [
- "."
+ ".",
],
target: {
android: {
@@ -62,14 +62,14 @@
"GrallocGoldfish.cpp",
"GrallocMinigbm.cpp",
],
- }
- }
+ },
+ },
}
cc_library_headers {
name: "libgfxstream_guest_sync",
export_include_dirs: [
- "."
+ ".",
],
}
@@ -98,14 +98,13 @@
],
shared_libs: [
"lib_renderControl_enc",
- "libandroidemu",
"libbase",
+ "libdrm",
"libcutils",
"libGLESv1_enc",
"libGLESv2_enc",
"liblog",
"libOpenglCodecCommon",
- "libvulkan_enc",
],
export_shared_lib_headers: [
"lib_renderControl_enc",
@@ -135,7 +134,7 @@
"VirtioGpuPipeStream.cpp",
],
export_include_dirs: [
- "."
+ ".",
],
target: {
android: {
@@ -153,6 +152,11 @@
"ANativeWindowAndroid.cpp",
],
},
+ host: {
+ srcs: [
+ "TestingAndroidWsi.cpp",
+ ],
+ },
},
}
@@ -161,7 +165,11 @@
defaults: [
"libOpenglSystemCommonDefaults",
],
+ shared_libs: [
+ "libandroidemu",
+ ],
static_libs: [
+ "libvulkan_enc",
"libplatform",
],
export_static_lib_headers: [
@@ -176,11 +184,58 @@
],
shared_libs: [
"libgfxstream_backend",
+ "libplatform_rutabaga",
+ "libandroidemu",
],
static_libs: [
+ "libgfxstream_guest_vulkan_encoder_with_host",
+ ],
+ export_shared_lib_headers: [
"libplatform_rutabaga",
],
+ target: {
+ host: {
+ compile_multilib: "64",
+ },
+ android: {
+ compile_multilib: "64",
+ },
+ },
+}
+
+cc_library_static {
+ name: "libgfxstream_guest_system_common",
+ defaults: [
+ "libOpenglSystemCommonDefaults",
+ ],
+ header_libs: [
+ "vulkan_enc_headers",
+ ],
+ static_libs: [
+ "libandroidemu_static",
+ "libplatform",
+ ],
export_static_lib_headers: [
+ "libplatform",
+ ],
+}
+
+cc_library_static {
+ name: "libgfxstream_guest_system_common_with_host",
+ defaults: [
+ "libOpenglSystemCommonDefaults",
+ ],
+ header_libs: [
+ "vulkan_enc_headers",
+ ],
+ shared_libs: [
+ "libgfxstream_backend",
+ "libplatform_rutabaga",
+ ],
+ static_libs: [
+ "libandroidemu_static",
+ ],
+ export_shared_lib_headers: [
"libplatform_rutabaga",
],
target: {
diff --git a/guest/OpenglSystemCommon/Gralloc.h b/guest/OpenglSystemCommon/Gralloc.h
index e5e2c8f..f5c99cf 100644
--- a/guest/OpenglSystemCommon/Gralloc.h
+++ b/guest/OpenglSystemCommon/Gralloc.h
@@ -23,6 +23,10 @@
namespace gfxstream {
+constexpr uint32_t kGlRGB = 0x1907;
+constexpr uint32_t kGlRGBA = 0x1908;
+constexpr uint32_t kGlRGB565 = 0x8D62;
+
// Abstraction for gralloc handle conversion
class Gralloc {
public:
diff --git a/guest/OpenglSystemCommon/GrallocMinigbm.cpp b/guest/OpenglSystemCommon/GrallocMinigbm.cpp
index 8e28996..9acf41b 100644
--- a/guest/OpenglSystemCommon/GrallocMinigbm.cpp
+++ b/guest/OpenglSystemCommon/GrallocMinigbm.cpp
@@ -109,8 +109,6 @@
uint32_t MinigbmGralloc::createColorBuffer(void*, int width, int height,
uint32_t glformat) {
// Only supported format for pbuffers in gfxstream should be RGBA8
- const uint32_t kGlRGB = 0x1907;
- const uint32_t kGlRGBA = 0x1908;
const uint32_t kVirglFormatRGBA = 67; // VIRGL_FORMAT_R8G8B8A8_UNORM;
uint32_t virtgpu_format = 0;
uint32_t bpp = 0;
diff --git a/guest/OpenglSystemCommon/TestingAndroidWsi.cpp b/guest/OpenglSystemCommon/TestingAndroidWsi.cpp
new file mode 100644
index 0000000..b62ff18
--- /dev/null
+++ b/guest/OpenglSystemCommon/TestingAndroidWsi.cpp
@@ -0,0 +1,346 @@
+/*
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <iostream>
+#include <cutils/log.h>
+
+#include "drm_fourcc.h"
+#include "TestingAndroidWsi.h"
+
+namespace gfxstream {
+
+static constexpr int numFds = 0;
+static constexpr int numInts = 1;
+
+std::optional<uint32_t> GlFormatToDrmFormat(uint32_t glFormat) {
+ switch (glFormat) {
+ case kGlRGB:
+ return DRM_FORMAT_BGR888;
+ case kGlRGB565:
+ return DRM_FORMAT_BGR565;
+ case kGlRGBA:
+ return DRM_FORMAT_ABGR8888;
+ }
+ return std::nullopt;
+}
+
+std::optional<uint32_t> DrmToVirglFormat(uint32_t drmFormat) {
+ switch (drmFormat) {
+ case DRM_FORMAT_ABGR8888:
+ return VIRGL_FORMAT_B8G8R8A8_UNORM;
+ case DRM_FORMAT_BGR888:
+ return VIRGL_FORMAT_R8G8B8_UNORM;
+ case DRM_FORMAT_BGR565:
+ return VIRGL_FORMAT_B5G6R5_UNORM;
+ }
+ return std::nullopt;
+}
+
+TestingAHardwareBuffer::TestingAHardwareBuffer(
+ uint32_t width,
+ uint32_t height,
+ VirtGpuBlobPtr resource)
+ : mWidth(width),
+ mHeight(height),
+ mResource(resource) {
+ mHandle = native_handle_create(numFds, numInts);
+ mHandle->data[0] = mResource->getResourceHandle();
+}
+
+TestingAHardwareBuffer::~TestingAHardwareBuffer() {
+ native_handle_close(mHandle);
+}
+
+uint32_t TestingAHardwareBuffer::getResourceId() const {
+ return mResource->getResourceHandle();
+}
+
+uint32_t TestingAHardwareBuffer::getWidth() const {
+ return mWidth;
+}
+
+uint32_t TestingAHardwareBuffer::getHeight() const {
+ return mHeight;
+}
+
+int TestingAHardwareBuffer::getAndroidFormat() const {
+ return /*AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM=*/1;
+}
+
+uint32_t TestingAHardwareBuffer::getDrmFormat() const {
+ return DRM_FORMAT_ABGR8888;
+}
+
+AHardwareBuffer* TestingAHardwareBuffer::asAHardwareBuffer() {
+ return reinterpret_cast<AHardwareBuffer*>(this);
+}
+
+buffer_handle_t TestingAHardwareBuffer::asBufferHandle() {
+ return reinterpret_cast<buffer_handle_t>(mHandle);
+}
+
+EGLClientBuffer TestingAHardwareBuffer::asEglClientBuffer() {
+ return reinterpret_cast<EGLClientBuffer>(this);
+}
+
+TestingVirtGpuGralloc::TestingVirtGpuGralloc() {}
+
+uint32_t TestingVirtGpuGralloc::createColorBuffer(
+ void*,
+ int width,
+ int height,
+ uint32_t glFormat) {
+ auto drmFormat = GlFormatToDrmFormat(glFormat);
+ if (!drmFormat) {
+ ALOGE("Unhandled format");
+ }
+
+ auto ahb = allocate(width, height, *drmFormat);
+
+ uint32_t hostHandle = ahb->getResourceId();
+ mAllocatedColorBuffers.emplace(hostHandle, std::move(ahb));
+ return hostHandle;
+}
+
+int TestingVirtGpuGralloc::allocate(
+ uint32_t width,
+ uint32_t height,
+ uint32_t format,
+ uint64_t usage,
+ AHardwareBuffer** outputAhb) {
+ (void)width;
+ (void)height;
+ (void)format;
+ (void)usage;
+ (void)outputAhb;
+
+ // TODO: support export flow?
+ ALOGE("Unimplemented");
+
+ return 0;
+}
+
+std::unique_ptr<TestingAHardwareBuffer> TestingVirtGpuGralloc::allocate(
+ uint32_t width,
+ uint32_t height,
+ uint32_t format) {
+ ALOGE("Allocating AHB w:%u, h:%u, format %u", width, height, format);
+
+ auto device = VirtGpuDevice::getInstance();
+ if (!device) {
+ ALOGE("Failed to allocate: no virtio gpu device.");
+ return nullptr;
+ }
+
+ auto virglFormat = DrmToVirglFormat(format);
+ if (!virglFormat) {
+ std::cout << "Unhandled DRM format:" << format;
+ return nullptr;
+ }
+
+ auto resource = device->createVirglBlob(width, height, *virglFormat);
+ if (!resource) {
+ ALOGE("Failed to allocate: failed to create virtio resource.");
+ return nullptr;
+ }
+
+ resource->wait();
+
+ return std::make_unique<TestingAHardwareBuffer>(width, height, std::move(resource));
+}
+
+void TestingVirtGpuGralloc::acquire(AHardwareBuffer* ahb) {
+ // TODO
+}
+
+void TestingVirtGpuGralloc::release(AHardwareBuffer* ahb) {
+ // TODO
+}
+
+uint32_t TestingVirtGpuGralloc::getHostHandle(const native_handle_t* handle) {
+ const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
+ return ahb->getResourceId();
+}
+
+uint32_t TestingVirtGpuGralloc::getHostHandle(const AHardwareBuffer* handle) {
+ const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
+ return ahb->getResourceId();
+}
+
+int TestingVirtGpuGralloc::getFormat(const native_handle_t* handle) {
+ const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
+ return ahb->getAndroidFormat();
+}
+
+int TestingVirtGpuGralloc::getFormat(const AHardwareBuffer* handle) {
+ const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
+ return ahb->getAndroidFormat();
+}
+
+uint32_t TestingVirtGpuGralloc::getFormatDrmFourcc(const AHardwareBuffer* handle) {
+ const auto* ahb = reinterpret_cast<const TestingAHardwareBuffer*>(handle);
+ return ahb->getDrmFormat();
+}
+
+size_t TestingVirtGpuGralloc::getAllocatedSize(const native_handle_t*) {
+ ALOGE("Unimplemented.");
+ return 0;
+}
+
+size_t TestingVirtGpuGralloc::getAllocatedSize(const AHardwareBuffer*) {
+ ALOGE("Unimplemented.");
+ return 0;
+}
+
+TestingANativeWindow::TestingANativeWindow(
+ uint32_t width,
+ uint32_t height,
+ uint32_t format,
+ std::vector<std::unique_ptr<TestingAHardwareBuffer>> buffers)
+ : mWidth(width),
+ mHeight(height),
+ mFormat(format),
+ mBuffers(std::move(buffers)) {
+ for (auto& buffer : mBuffers) {
+ mBufferQueue.push_back(QueuedAHB{
+ .ahb = buffer.get(),
+ .fence = -1,
+ });
+ }
+}
+
+EGLNativeWindowType TestingANativeWindow::asEglNativeWindowType() {
+ return reinterpret_cast<EGLNativeWindowType>(this);
+}
+
+uint32_t TestingANativeWindow::getWidth() const {
+ return mWidth;
+}
+
+uint32_t TestingANativeWindow::getHeight() const {
+ return mHeight;
+}
+
+int TestingANativeWindow::getFormat() const {
+ return mFormat;
+}
+
+int TestingANativeWindow::queueBuffer(EGLClientBuffer buffer, int fence) {
+ auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
+
+ mBufferQueue.push_back(QueuedAHB{
+ .ahb = ahb,
+ .fence = fence,
+ });
+
+ return 0;
+}
+
+int TestingANativeWindow::dequeueBuffer(EGLClientBuffer* buffer, int* fence) {
+ auto queuedAhb = mBufferQueue.front();
+ mBufferQueue.pop_front();
+
+ *buffer = queuedAhb.ahb->asEglClientBuffer();
+ *fence = queuedAhb.fence;
+ return 0;
+}
+
+int TestingANativeWindow::cancelBuffer(EGLClientBuffer buffer) {
+ auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
+
+ mBufferQueue.push_back(QueuedAHB{
+ .ahb = ahb,
+ .fence = -1,
+ });
+
+ return 0;
+}
+
+bool TestingVirtGpuANativeWindowHelper::isValid(EGLNativeWindowType window) {
+ // TODO: maybe a registry of valid TestingANativeWindow-s?
+ return true;
+}
+
+bool TestingVirtGpuANativeWindowHelper::isValid(EGLClientBuffer buffer) {
+ // TODO: maybe a registry of valid TestingAHardwareBuffer-s?
+ return true;
+}
+
+void TestingVirtGpuANativeWindowHelper::acquire(EGLNativeWindowType window) {
+ // TODO: maybe a registry of valid TestingANativeWindow-s?
+}
+
+void TestingVirtGpuANativeWindowHelper::release(EGLNativeWindowType window) {
+ // TODO: maybe a registry of valid TestingANativeWindow-s?
+}
+
+void TestingVirtGpuANativeWindowHelper::acquire(EGLClientBuffer buffer) {
+ // TODO: maybe a registry of valid TestingAHardwareBuffer-s?
+}
+
+void TestingVirtGpuANativeWindowHelper::release(EGLClientBuffer buffer) {
+ // TODO: maybe a registry of valid TestingAHardwareBuffer-s?
+}
+
+int TestingVirtGpuANativeWindowHelper::getConsumerUsage(EGLNativeWindowType window, int* usage) {
+ (void)window;
+ (void)usage;
+ return 0;
+}
+void TestingVirtGpuANativeWindowHelper::setUsage(EGLNativeWindowType window, int usage) {
+ (void)window;
+ (void)usage;
+}
+
+int TestingVirtGpuANativeWindowHelper::getWidth(EGLNativeWindowType window) {
+ auto anw = reinterpret_cast<TestingANativeWindow*>(window);
+ return anw->getWidth();
+}
+
+int TestingVirtGpuANativeWindowHelper::getHeight(EGLNativeWindowType window) {
+ auto anw = reinterpret_cast<TestingANativeWindow*>(window);
+ return anw->getHeight();
+}
+
+int TestingVirtGpuANativeWindowHelper::getWidth(EGLClientBuffer buffer) {
+ auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
+ return ahb->getWidth();
+}
+
+int TestingVirtGpuANativeWindowHelper::getHeight(EGLClientBuffer buffer) {
+ auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
+ return ahb->getHeight();
+}
+
+int TestingVirtGpuANativeWindowHelper::getFormat(EGLClientBuffer buffer, Gralloc* helper) {
+ auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
+ return ahb->getAndroidFormat();
+}
+
+void TestingVirtGpuANativeWindowHelper::setSwapInterval(EGLNativeWindowType window, int interval) {
+ ALOGE("Unimplemented");
+}
+
+int TestingVirtGpuANativeWindowHelper::queueBuffer(EGLNativeWindowType window, EGLClientBuffer buffer, int fence) {
+ auto anw = reinterpret_cast<TestingANativeWindow*>(window);
+ return anw->queueBuffer(buffer, fence);
+}
+
+int TestingVirtGpuANativeWindowHelper::dequeueBuffer(EGLNativeWindowType window, EGLClientBuffer* buffer, int* fence) {
+ auto anw = reinterpret_cast<TestingANativeWindow*>(window);
+ return anw->dequeueBuffer(buffer, fence);
+}
+
+int TestingVirtGpuANativeWindowHelper::cancelBuffer(EGLNativeWindowType window, EGLClientBuffer buffer) {
+ auto anw = reinterpret_cast<TestingANativeWindow*>(window);
+ return anw->cancelBuffer(buffer);
+}
+
+int TestingVirtGpuANativeWindowHelper::getHostHandle(EGLClientBuffer buffer, Gralloc*) {
+ auto ahb = reinterpret_cast<TestingAHardwareBuffer*>(buffer);
+ return ahb->getResourceId();
+}
+
+} // namespace gfxstream
diff --git a/guest/OpenglSystemCommon/TestingAndroidWsi.h b/guest/OpenglSystemCommon/TestingAndroidWsi.h
new file mode 100644
index 0000000..b18455e
--- /dev/null
+++ b/guest/OpenglSystemCommon/TestingAndroidWsi.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <optional>
+#include <queue>
+#include <unordered_map>
+#include <vector>
+
+#include "VirtGpu.h"
+#include "ANativeWindow.h"
+
+namespace gfxstream {
+
+class TestingAHardwareBuffer {
+ public:
+ TestingAHardwareBuffer(uint32_t width,
+ uint32_t height,
+ VirtGpuBlobPtr resource);
+
+ ~TestingAHardwareBuffer();
+
+ uint32_t getResourceId() const;
+
+ uint32_t getWidth() const;
+
+ uint32_t getHeight() const;
+
+ int getAndroidFormat() const;
+
+ uint32_t getDrmFormat() const;
+
+ AHardwareBuffer* asAHardwareBuffer();
+
+ buffer_handle_t asBufferHandle();
+
+ EGLClientBuffer asEglClientBuffer();
+
+ private:
+ uint32_t mWidth;
+ uint32_t mHeight;
+ VirtGpuBlobPtr mResource;
+ native_handle_t *mHandle = nullptr;
+};
+
+class TestingVirtGpuGralloc : public Gralloc {
+ public:
+ TestingVirtGpuGralloc();
+
+ uint32_t createColorBuffer(void*,
+ int width,
+ int height,
+ uint32_t glFormat) override;
+
+ int allocate(uint32_t width,
+ uint32_t height,
+ uint32_t format,
+ uint64_t usage,
+ AHardwareBuffer** outputAhb) override;
+
+ std::unique_ptr<TestingAHardwareBuffer> allocate(uint32_t width,
+ uint32_t height,
+ uint32_t format);
+
+ void acquire(AHardwareBuffer* ahb) override;
+ void release(AHardwareBuffer* ahb) override;
+
+ uint32_t getHostHandle(const native_handle_t* handle) override;
+ uint32_t getHostHandle(const AHardwareBuffer* handle) override;
+
+ int getFormat(const native_handle_t* handle) override;
+ int getFormat(const AHardwareBuffer* handle) override;
+
+ uint32_t getFormatDrmFourcc(const AHardwareBuffer* handle) override;
+
+ size_t getAllocatedSize(const native_handle_t*) override;
+ size_t getAllocatedSize(const AHardwareBuffer*) override;
+
+ private:
+ std::unordered_map<uint32_t, std::unique_ptr<TestingAHardwareBuffer>> mAllocatedColorBuffers;
+};
+
+class TestingANativeWindow {
+ public:
+ TestingANativeWindow(uint32_t width,
+ uint32_t height,
+ uint32_t format,
+ std::vector<std::unique_ptr<TestingAHardwareBuffer>> buffers);
+
+ EGLNativeWindowType asEglNativeWindowType();
+
+ uint32_t getWidth() const;
+
+ uint32_t getHeight() const;
+
+ int getFormat() const;
+
+ int queueBuffer(EGLClientBuffer buffer, int fence);
+ int dequeueBuffer(EGLClientBuffer* buffer, int* fence);
+ int cancelBuffer(EGLClientBuffer buffer);
+
+ private:
+ uint32_t mWidth;
+ uint32_t mHeight;
+ uint32_t mFormat;
+ std::vector<std::unique_ptr<TestingAHardwareBuffer>> mBuffers;
+
+ struct QueuedAHB {
+ TestingAHardwareBuffer* ahb;
+ int fence = -1;
+ };
+ std::deque<QueuedAHB> mBufferQueue;
+};
+
+class TestingVirtGpuANativeWindowHelper : public ANativeWindowHelper {
+ public:
+ bool isValid(EGLNativeWindowType window) override;
+ bool isValid(EGLClientBuffer buffer) override;
+
+ void acquire(EGLNativeWindowType window) override;
+ void release(EGLNativeWindowType window) override;
+
+ void acquire(EGLClientBuffer buffer) override;
+ void release(EGLClientBuffer buffer) override;
+
+ int getConsumerUsage(EGLNativeWindowType window, int* usage) override;
+ void setUsage(EGLNativeWindowType window, int usage) override;
+
+ int getWidth(EGLNativeWindowType window) override;
+ int getHeight(EGLNativeWindowType window) override;
+
+ int getWidth(EGLClientBuffer buffer) override;
+ int getHeight(EGLClientBuffer buffer) override;
+
+ int getFormat(EGLClientBuffer buffer, Gralloc* helper) override;
+
+ void setSwapInterval(EGLNativeWindowType window, int interval) override;
+
+ int queueBuffer(EGLNativeWindowType window, EGLClientBuffer buffer, int fence) override;
+ int dequeueBuffer(EGLNativeWindowType window, EGLClientBuffer* buffer, int* fence) override;
+ int cancelBuffer(EGLNativeWindowType window, EGLClientBuffer buffer) override;
+
+ int getHostHandle(EGLClientBuffer buffer, Gralloc*) override;
+};
+
+} // namespace gfxstream
diff --git a/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp b/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp
index ca8ec05..643b6c4 100644
--- a/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp
+++ b/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp
@@ -24,15 +24,6 @@
#include "virtgpu_drm.h"
#include "VirtGpu.h"
-// In a virtual machine, there should only be one GPU
-#define RENDERNODE_MINOR 128
-
-// Attributes use to allocate our response buffer
-// Similar to virgl's fence objects
-#define PIPE_BUFFER 0
-#define VIRGL_FORMAT_R8_UNORM 64
-#define VIRGL_BIND_CUSTOM (1 << 17)
-
static const size_t kTransferBufferSize = (1048576);
static const size_t kReadSize = 512 * 1024;
@@ -78,7 +69,7 @@
return -1;
}
- m_resource = m_device->createPipeBlob(kTransferBufferSize);
+ m_resource = m_device->createVirglBlob(kTransferBufferSize, 1, VIRGL_FORMAT_R8_UNORM);
if (!m_resource) {
ALOGE("Failed to create VirtioGpuPipeStream resource.");
return -1;
diff --git a/guest/android-emu/Android.bp b/guest/android-emu/Android.bp
index 4076d5e..96d7ef6 100644
--- a/guest/android-emu/Android.bp
+++ b/guest/android-emu/Android.bp
@@ -47,6 +47,49 @@
}
cc_library_static {
+ name: "libandroidemu_static",
+ defaults: [
+ "libgfxstream_guest_cc_defaults",
+ ],
+ host_supported: true,
+ vendor: true,
+ srcs: [
+ "aemu/base/AlignedBuf.cpp",
+ "aemu/base/files/MemStream.cpp",
+ "aemu/base/files/Stream.cpp",
+ "aemu/base/files/StreamSerializing.cpp",
+ "aemu/base/Path.cpp",
+ "aemu/base/Pool.cpp",
+ "aemu/base/StringFormat.cpp",
+ "aemu/base/Process.cpp",
+ "aemu/base/AndroidSubAllocator.cpp",
+ "aemu/base/synchronization/AndroidMessageChannel.cpp",
+ "aemu/base/threads/AndroidFunctorThread.cpp",
+ "aemu/base/threads/AndroidThreadStore.cpp",
+ "aemu/base/threads/AndroidThread_pthread.cpp",
+ "aemu/base/threads/AndroidWorkPool.cpp",
+ "aemu/base/AndroidHealthMonitor.cpp",
+ "aemu/base/AndroidHealthMonitorConsumerBasic.cpp",
+ "aemu/base/Tracing.cpp",
+ "android/utils/debug.c",
+ ],
+ shared_libs: [
+ "libcutils",
+ "libutils",
+ "liblog",
+ ],
+ export_include_dirs: [
+ ".",
+ ],
+ cflags: [
+ "-DLOG_TAG=\"androidemu\"",
+ "-Wno-missing-field-initializers",
+ "-fvisibility=default",
+ "-fstrict-aliasing",
+ ],
+}
+
+cc_library_static {
name: "libringbuffer",
host_supported: true,
vendor: true,
diff --git a/guest/egl/Android.bp b/guest/egl/Android.bp
index 7243fac..4c1d603 100644
--- a/guest/egl/Android.bp
+++ b/guest/egl/Android.bp
@@ -90,10 +90,8 @@
],
shared_libs: [
"libOpenglSystemCommonWithHost",
- "libgfxstream_backend",
- ],
- static_libs: [
"libplatform_rutabaga",
+ "libgfxstream_backend",
],
target: {
host: {
diff --git a/guest/iostream/Android.bp b/guest/iostream/Android.bp
index 8749b95..a176f23 100644
--- a/guest/iostream/Android.bp
+++ b/guest/iostream/Android.bp
@@ -41,4 +41,4 @@
export_include_dirs: [
"include",
],
-}
\ No newline at end of file
+}
diff --git a/guest/mesa/Android.bp b/guest/mesa/Android.bp
new file mode 100644
index 0000000..8e1a718
--- /dev/null
+++ b/guest/mesa/Android.bp
@@ -0,0 +1,133 @@
+cc_library_headers {
+ name: "mesa_common_headers_gfxstream",
+ export_include_dirs: [
+ "src",
+ "include",
+ ],
+ host_supported: true,
+ vendor: true,
+}
+
+cc_defaults {
+ name: "mesa_common_defaults_gfxstream",
+
+ // uncomment to keep the debug symbols
+ // strip: { none: true, },
+
+ vendor: true,
+ header_libs: ["mesa_common_headers_gfxstream"],
+
+ cflags: [
+ "-Wno-error",
+ "-Werror=incompatible-pointer-types",
+ "-Wno-unused-parameter",
+ "-Wno-pointer-arith",
+ "-Wno-missing-field-initializers",
+ "-Wno-initializer-overrides",
+ "-Wno-mismatched-tags",
+ "-DPACKAGE_VERSION=\"20.3.4\"",
+ // PACKAGE_VERSION is in mesa_version_defaults
+ "-DPACKAGE_BUGREPORT=\"https://bugs.freedesktop.org/enter_bug.cgi?product=Mesa\"",
+
+ // XXX: The following __STDC_*_MACROS defines should not be needed.
+ // It's likely due to a bug elsewhere, but let's temporarily add them
+ // here to fix the radeonsi build.
+ "-DENABLE_SHADER_CACHE",
+ "-D__STDC_CONSTANT_MACROS",
+ "-D__STDC_LIMIT_MACROS",
+ "-DHAVE___BUILTIN_EXPECT",
+ "-DHAVE___BUILTIN_FFS",
+ "-DHAVE___BUILTIN_FFSLL",
+ "-DHAVE_DLFCN_H",
+ "-DHAVE_FUNC_ATTRIBUTE_FLATTEN",
+ "-DHAVE_FUNC_ATTRIBUTE_UNUSED",
+ "-DHAVE_FUNC_ATTRIBUTE_FORMAT",
+ "-DHAVE_FUNC_ATTRIBUTE_PACKED",
+ "-DHAVE_FUNC_ATTRIBUTE_ALIAS",
+ "-DHAVE_FUNC_ATTRIBUTE_NORETURN",
+ "-DHAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL",
+ "-DHAVE_FUNC_ATTRIBUTE_WARN_UNUSED_RESULT",
+ "-DHAVE___BUILTIN_CTZ",
+ "-DHAVE___BUILTIN_POPCOUNT",
+ "-DHAVE___BUILTIN_POPCOUNTLL",
+ "-DHAVE___BUILTIN_CLZ",
+ "-DHAVE___BUILTIN_CLZLL",
+ "-DHAVE___BUILTIN_UNREACHABLE",
+ "-DHAVE_PTHREAD=1",
+ "-DUSE_XMLCONFIG=0",
+ "-DHAVE_DLADDR",
+ "-DHAVE_DL_ITERATE_PHDR",
+ "-DHAVE_LINUX_FUTEX_H",
+ "-DHAVE_ENDIAN_H",
+ "-DMAJOR_IN_SYSMACROS",
+ "-DVK_USE_PLATFORM_ANDROID_KHR",
+ "-fvisibility=hidden",
+ "-fno-math-errno",
+ "-fno-trapping-math",
+ "-Werror",
+ "-Wno-#warnings",
+ "-Wno-asm-operand-widths",
+ "-Wno-cast-calling-convention",
+ "-Wno-constant-logical-operand",
+ "-Wno-enum-conversion",
+ "-Wno-format",
+ "-Wno-gnu-variable-sized-type-not-at-end",
+ "-Wno-implicit-fallthrough",
+ "-Wno-incompatible-pointer-types",
+ "-Wno-missing-braces",
+ "-Wno-overloaded-virtual",
+ "-Wno-self-assign",
+ "-Wno-shift-negative-value",
+ "-Wno-sign-compare",
+ "-Wno-sometimes-uninitialized",
+ "-Wno-switch",
+ "-Wno-typedef-redefinition",
+ "-Wno-uninitialized",
+ "-Wno-implicit-const-int-float-conversion",
+ "-Wno-sync-alignment",
+ "-Wno-visibility",
+ "-Wno-implicit-function-declaration",
+ "-Wno-int-conversion",
+ "-Wno-implicit-int",
+ "-Wno-unknown-pragmas",
+ "-DHAVE_TIMESPEC_GET",
+ "-DHAVE_STRUCT_TIMESPEC",
+ ],
+
+ c_std: "c11",
+
+ cppflags: [
+ "-D__STDC_CONSTANT_MACROS",
+ "-D__STDC_FORMAT_MACROS",
+ "-D__STDC_LIMIT_MACROS",
+ "-Wno-error=non-virtual-dtor",
+ "-Wno-non-virtual-dtor",
+ ],
+
+ arch: {
+ arm: {
+ neon: {
+ cflags: ["-DUSE_ARM_ASM"],
+ },
+ },
+ arm64: {
+ cflags: ["-DUSE_AARCH64_ASM"],
+ },
+ },
+
+ product_variables: {
+ platform_sdk_version: {
+ cflags: ["-DANDROID_API_LEVEL=%d"],
+ },
+ },
+
+ target: {
+ host: {
+ cflags: [
+ "-D_GNU_SOURCE",
+ "-DHAVE_LIBDRM",
+ ],
+ shared_libs: ["libdrm"],
+ },
+ },
+}
diff --git a/guest/mesa/Android.gen.bp b/guest/mesa/Android.gen.bp
new file mode 100644
index 0000000..1d378d0
--- /dev/null
+++ b/guest/mesa/Android.gen.bp
@@ -0,0 +1,5 @@
+// Autogenerated by aosp-gen-bp.sh
+cc_defaults {
+ name: "gfxstream_mesa_version_defaults",
+ cflags: ["-DPACKAGE_VERSION=\"20.3.4\""],
+}
diff --git a/guest/mesa/include/Android.bp b/guest/mesa/include/Android.bp
new file mode 100644
index 0000000..af2af73
--- /dev/null
+++ b/guest/mesa/include/Android.bp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+cc_library_headers {
+ name: "libgfxstream_guest_mesa_graphics_headers",
+ host_supported: true,
+ vendor_available: true,
+ defaults: [
+ "libgfxstream_guest_cc_defaults",
+ ],
+ export_include_dirs: [
+ ".",
+ ],
+}
diff --git a/guest/mesa/src/c11/Android.bp b/guest/mesa/src/c11/Android.bp
new file mode 100644
index 0000000..74edbbd
--- /dev/null
+++ b/guest/mesa/src/c11/Android.bp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+cc_library_headers {
+ name: "mesa_util_c11_headers_gfxstream",
+ export_include_dirs: ["."],
+ host_supported: true,
+ vendor: true,
+}
diff --git a/guest/mesa/src/c11/impl/Android.bp b/guest/mesa/src/c11/impl/Android.bp
new file mode 100644
index 0000000..0491391
--- /dev/null
+++ b/guest/mesa/src/c11/impl/Android.bp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+cc_library_static {
+ name: "libmesa_util_c11_gfxstream",
+ host_supported: true,
+ vendor: true,
+ defaults: [
+ "mesa_common_defaults_gfxstream",
+ ],
+ header_libs: [
+ "mesa_common_headers_gfxstream",
+ ],
+ srcs: [
+ "time.c",
+ "threads_posix.c",
+ ],
+}
diff --git a/guest/mesa/src/util/Android.bp b/guest/mesa/src/util/Android.bp
new file mode 100644
index 0000000..731881a
--- /dev/null
+++ b/guest/mesa/src/util/Android.bp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+filegroup {
+ name: "libmesa_drirc",
+ srcs: ["00-mesa-defaults.conf"],
+}
+
+python_binary_host {
+ name: "format_srgb_gen",
+ main: "format_srgb.py",
+ srcs: ["format_srgb.py"],
+}
+
+python_binary_host {
+ name: "driconf_static_gen",
+ main: "driconf_static.py",
+ srcs: ["driconf_static.py"],
+ libs: [
+ "mako",
+ ],
+}
+
+genrule {
+ name: "format_srgb_impl",
+ out: ["format_srgb.c"],
+ tools: ["format_srgb_gen"],
+ cmd: "python3 $(location format_srgb_gen) " +
+ "&> $(location format_srgb.c)",
+}
+
+genrule {
+ name: "driconf_static_header",
+ srcs: [":libmesa_drirc"],
+ out: ["driconf_static.h"],
+ tools: ["driconf_static_gen"],
+ cmd: "python3 $(location driconf_static_gen) " +
+ "$(location :libmesa_drirc) " +
+ "$(location driconf_static.h)",
+}
+
+cc_library_headers {
+ name: "libmesa_util_headers_gfxstream",
+ host_supported: true,
+ vendor_available: true,
+ export_include_dirs: [
+ ".",
+ ],
+}
+
+cc_library_static {
+ name: "libmesa_util_gfxstream",
+ host_supported: true,
+ vendor: true,
+ defaults: [
+ "mesa_common_defaults_gfxstream",
+ ],
+ generated_headers: [
+ "driconf_static_header",
+ ],
+ static_libs: [
+ "libmesa_util_c11_gfxstream",
+ ],
+ shared_libs: [
+ "liblog",
+ "libcutils",
+ ],
+ srcs: [
+ "anon_file.c",
+ "bitscan.c",
+ "blob.c",
+ "build_id.c",
+ "compress.c",
+ "crc32.c",
+ "dag.c",
+ "double.c",
+ "disk_cache.c",
+ "disk_cache_os.c",
+ "fast_idiv_by_const.c",
+ "fossilize_db.c",
+ "futex.c",
+ "half_float.c",
+ "hash_table.c",
+ "u_idalloc.c",
+ "log.c",
+ "memstream.c",
+ "mesa-sha1.c",
+ "mesa-blake3.c",
+ "os_time.c",
+ "os_file.c",
+ "os_memory_fd.c",
+ "os_misc.c",
+ "os_socket.c",
+ "perf/u_trace.c",
+ "u_process.c",
+ "u_qsort.cpp",
+ "rwlock.c",
+ "sha1/sha1.c",
+ "ralloc.c",
+ "rand_xor.c",
+ "rb_tree.c",
+ "register_allocate.c",
+ "rgtc.c",
+ "set.c",
+ "simple_mtx.c",
+ "slab.c",
+ "softfloat.c",
+ "sparse_array.c",
+ "string_buffer.c",
+ "strtod.c",
+ "u_atomic.c",
+ "u_call_once.c",
+ "u_dl.c",
+ "u_dynarray.c",
+ "u_hash_table.c",
+ "u_queue.c",
+ "u_thread.c",
+ "u_vector.c",
+ "u_math.c",
+ "u_mm.c",
+ "u_debug.c",
+ "u_debug_memory.c",
+ "u_cpu_detect.c",
+ "u_printf.c",
+ "u_worklist.c",
+ "vl_zscan_data.c",
+ "vma.c",
+ "mesa_cache_db.c",
+ "mesa_cache_db_multipart.c",
+ "xmlconfig.c",
+ ],
+ target: {
+ host: {
+ header_libs: [
+ "mesa_common_headers_gfxstream",
+ ],
+ cflags: [
+ "-DHAVE_PROGRAM_INVOCATION_NAME",
+ ],
+ },
+ android: {
+ header_libs: [
+ "mesa_common_headers_gfxstream",
+ ],
+ cflags: [
+ "-DHAVE_MEMFD_CREATE",
+ ],
+ },
+ },
+}
diff --git a/guest/mesa/src/util/format/Android.bp b/guest/mesa/src/util/format/Android.bp
new file mode 100644
index 0000000..056642b
--- /dev/null
+++ b/guest/mesa/src/util/format/Android.bp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+filegroup {
+ name: "libmesa_u_format_csv",
+ srcs: ["u_format.csv"],
+}
+
+python_binary_host {
+ name: "u_format_table_gen",
+ main: "u_format_table.py",
+ srcs: [
+ "u_format_table.py",
+ "u_format_pack.py",
+ "u_format_parse.py",
+ ],
+}
+
+genrule {
+ name: "u_format_pack_header",
+ srcs: [":libmesa_u_format_csv"],
+ out: ["u_format_pack.h"],
+ tools: ["u_format_table_gen"],
+ cmd: "python3 $(location u_format_table_gen) " +
+ "$(location :libmesa_u_format_csv) --header" +
+ "&> $(location u_format_pack.h)"
+}
+
+genrule {
+ name: "u_format_table_impl",
+ srcs: [":libmesa_u_format_csv"],
+ out: ["u_format_table.c"],
+ tools: ["u_format_table_gen"],
+ cmd: "python3 $(location u_format_table_gen) " +
+ "$(location :libmesa_u_format_csv) " +
+ "&> $(location u_format_table.c)"
+}
+
+cc_library_static {
+ name: "libmesa_util_format_gfxstream",
+ host_supported: true,
+ vendor: true,
+ defaults: [
+ "mesa_common_defaults_gfxstream",
+ ],
+ header_libs: [
+ "mesa_common_headers_gfxstream",
+ "libmesa_util_headers_gfxstream",
+ ],
+ generated_headers: [
+ "u_format_pack_header",
+ ],
+ generated_sources: [
+ "u_format_table_impl",
+ "format_srgb_impl",
+ ],
+ srcs: [
+ "u_format.c",
+ "u_format_bptc.c",
+ "u_format_etc.c",
+ "u_format_fxt1.c",
+ "u_format_latc.c",
+ "u_format_other.c",
+ "u_format_rgtc.c",
+ "u_format_s3tc.c",
+ "u_format_tests.c",
+ "u_format_unpack_neon.c",
+ "u_format_yuv.c",
+ "u_format_zs.c",
+ ],
+}
diff --git a/guest/mesa/src/vulkan/registry/Android.bp b/guest/mesa/src/vulkan/registry/Android.bp
new file mode 100644
index 0000000..66cb256
--- /dev/null
+++ b/guest/mesa/src/vulkan/registry/Android.bp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+filegroup {
+ name: "libmesa_vulkan_xml",
+ srcs: ["vk.xml"],
+}
diff --git a/guest/mesa/src/vulkan/runtime/Android.bp b/guest/mesa/src/vulkan/runtime/Android.bp
new file mode 100644
index 0000000..255f05f
--- /dev/null
+++ b/guest/mesa/src/vulkan/runtime/Android.bp
@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+python_binary_host {
+ name: "vk_format_info_gen",
+ srcs: ["vk_format_info_gen.py"],
+ libs: [
+ "mako",
+ ],
+}
+
+genrule {
+ name: "vk_cmd_queue_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_cmd_queue.h"],
+ tools: ["vk_cmd_queue_gen"],
+ cmd: "python3 $(location vk_cmd_queue_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(location vk_cmd_queue.h) --out-c " +
+ "$(genDir)/placeholder.c --beta false",
+}
+
+genrule {
+ name: "vk_cmd_queue_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_cmd_queue.c"],
+ tools: ["vk_cmd_queue_gen"],
+ cmd: "python3 $(location vk_cmd_queue_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-c " +
+ "$(location vk_cmd_queue.c) --out-h " +
+ "$(genDir)/vk_cmd_queue.h --beta false",
+}
+
+genrule {
+ name: "vk_common_entrypoints_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_common_entrypoints.h"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(location vk_common_entrypoints.h) --out-c " +
+ "$(genDir)/placeholder.c --prefix vk_common --beta false",
+}
+
+genrule {
+ name: "vk_common_entrypoints_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_common_entrypoints.c"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(genDir)/vk_common_entrypoints.h --out-c " +
+ "$(location vk_common_entrypoints.c) --prefix vk_common " +
+ "--beta false",
+}
+
+genrule {
+ name: "vk_cmd_enqueue_entrypoints_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_cmd_enqueue_entrypoints.h"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(location vk_cmd_enqueue_entrypoints.h) --out-c " +
+ "$(genDir)/placeholder.c --prefix vk_cmd_enqueue " +
+ " --prefix vk_cmd_enqueue_unless_primary --beta false",
+}
+
+genrule {
+ name: "vk_cmd_enqueue_entrypoints_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_cmd_enqueue_entrypoints.c"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(genDir)/vk_cmd_enqueue_entrypoints.h --out-c " +
+ "$(location vk_cmd_enqueue_entrypoints.c) --prefix vk_cmd_enqueue " +
+ "--prefix vk_cmd_enqueue_unless_primary --beta false",
+}
+
+genrule {
+ name: "vk_dispatch_trampolines_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_dispatch_trampolines.h"],
+ tools: ["vk_dispatch_trampolines_gen"],
+ cmd: "python3 $(location vk_dispatch_trampolines_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(location vk_dispatch_trampolines.h) --out-c " +
+ "$(genDir)/placeholder.c --beta false",
+}
+
+genrule {
+ name: "vk_dispatch_trampolines_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_dispatch_trampolines.c"],
+ tools: ["vk_dispatch_trampolines_gen"],
+ cmd: "python3 $(location vk_dispatch_trampolines_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(genDir)/vk_dispatch_trampolines.h --out-c " +
+ "$(location vk_dispatch_trampolines.c) --beta false",
+}
+
+genrule {
+ name: "vk_physical_device_features_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_physical_device_features.h"],
+ tools: ["vk_physical_device_features_gen"],
+ cmd: "python3 $(location vk_physical_device_features_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(location vk_physical_device_features.h) --out-c " +
+ "$(genDir)/placeholder.c --beta false",
+}
+
+genrule {
+ name: "vk_physical_device_features_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_physical_device_features.c"],
+ tools: ["vk_physical_device_features_gen"],
+ cmd: "python3 $(location vk_physical_device_features_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(genDir)/vk_physical_device_features.h --out-c " +
+ "$(location vk_physical_device_features.c) --beta false",
+}
+
+genrule {
+ name: "vk_physical_device_properties_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_physical_device_properties.h"],
+ tools: ["vk_physical_device_properties_gen"],
+ cmd: "python3 $(location vk_physical_device_properties_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(location vk_physical_device_properties.h) --out-c " +
+ "$(genDir)/placeholder.c --beta false",
+}
+
+genrule {
+ name: "vk_physical_device_properties_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_physical_device_properties.c"],
+ tools: ["vk_physical_device_properties_gen"],
+ cmd: "python3 $(location vk_physical_device_properties_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(genDir)/vk_physical_device_properties.h --out-c " +
+ "$(location vk_physical_device_properties.c) --beta false",
+}
+
+genrule {
+ name: "vk_format_info_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_format_info.h"],
+ tools: ["vk_format_info_gen"],
+ cmd: "python3 $(location vk_format_info_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(location vk_format_info.h) --out-c " +
+ "$(genDir)/placeholder.c",
+}
+
+genrule {
+ name: "vk_format_info_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_format_info.c"],
+ tools: ["vk_format_info_gen"],
+ cmd: "python3 $(location vk_format_info_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(genDir)/vk_format_info.h --out-c " +
+ "$(location vk_format_info.c)",
+}
+
+cc_library_static {
+ name: "libmesa_vulkan_runtime_gfxstream",
+ host_supported: true,
+ vendor: true,
+ defaults: [
+ "mesa_common_defaults_gfxstream",
+ ],
+ header_libs: [
+ "mesa_common_headers_gfxstream",
+ ],
+ static_libs: [
+ "libarect",
+ "libmesa_util_gfxstream",
+ "libmesa_vulkan_util_gfxstream",
+ "libmesa_util_c11_gfxstream",
+ "libmesa_util_format_gfxstream",
+ ],
+ cflags: [
+ "-DVK_NO_NIR",
+ ],
+ generated_headers: [
+ "vk_cmd_queue_header",
+ "vk_common_entrypoints_header",
+ "vk_cmd_enqueue_entrypoints_header",
+ "vk_dispatch_trampolines_header",
+ "vk_physical_device_features_header",
+ "vk_physical_device_properties_header",
+ "vk_format_info_header",
+ ],
+ generated_sources: [
+ "vk_cmd_queue_impl",
+ "vk_common_entrypoints_impl",
+ "vk_cmd_enqueue_entrypoints_impl",
+ "vk_dispatch_trampolines_impl",
+ "vk_physical_device_features_impl",
+ "vk_physical_device_properties_impl",
+ "vk_format_info_impl",
+ ],
+ srcs: [
+ "rmv/vk_rmv_common.c",
+ "rmv/vk_rmv_exporter.c",
+ "vk_acceleration_structure.c",
+ "vk_blend.c",
+ "vk_buffer.c",
+ "vk_buffer_view.c",
+ "vk_cmd_copy.c",
+ "vk_cmd_enqueue.c",
+ "vk_command_buffer.c",
+ "vk_command_pool.c",
+ "vk_debug_report.c",
+ "vk_debug_utils.c",
+ "vk_deferred_operation.c",
+ "vk_descriptor_set_layout.c",
+ "vk_descriptors.c",
+ "vk_descriptor_update_template.c",
+ "vk_device.c",
+ "vk_device_memory.c",
+ "vk_fence.c",
+ "vk_framebuffer.c",
+ "vk_graphics_state.c",
+ "vk_image.c",
+ "vk_instance.c",
+ "vk_log.c",
+ "vk_object.c",
+ "vk_physical_device.c",
+ "vk_pipeline_layout.c",
+ "vk_query_pool.c",
+ "vk_queue.c",
+ "vk_render_pass.c",
+ "vk_sampler.c",
+ "vk_semaphore.c",
+ "vk_standard_sample_locations.c",
+ "vk_sync.c",
+ "vk_sync_binary.c",
+ "vk_sync_dummy.c",
+ "vk_sync_timeline.c",
+ "vk_synchronization2.c",
+ "vk_video.c",
+ "vk_ycbcr_conversion.c",
+ ],
+ export_include_dirs: [
+ ".",
+ ],
+ target: {
+ android: {
+ shared_libs: [
+ "libnativewindow",
+ "libsync",
+ "libcutils",
+ ],
+ header_libs: [
+ "hwvulkan_headers",
+ "libnativewindow_headers",
+ ],
+ srcs: [
+ "vk_android.c",
+ ],
+ },
+ },
+}
diff --git a/guest/mesa/src/vulkan/util/Android.bp b/guest/mesa/src/vulkan/util/Android.bp
new file mode 100644
index 0000000..f82dc0b
--- /dev/null
+++ b/guest/mesa/src/vulkan/util/Android.bp
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+python_binary_host {
+ name: "vk_cmd_queue_gen",
+ srcs: [
+ "vk_cmd_queue_gen.py",
+ "vk_entrypoints.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "vk_entrypoints_gen",
+ srcs: [
+ "vk_entrypoints_gen.py",
+ "vk_entrypoints.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "vk_dispatch_trampolines_gen",
+ srcs: [
+ "vk_dispatch_trampolines_gen.py",
+ "vk_entrypoints.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "vk_physical_device_features_gen",
+ srcs: [
+ "vk_physical_device_features_gen.py",
+ "vk_entrypoints.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "vk_physical_device_properties_gen",
+ srcs: [
+ "vk_physical_device_properties_gen.py",
+ "vk_entrypoints.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "vk_extensions_gen",
+ srcs: [
+ "vk_extensions_gen.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "vk_dispatch_table_gen",
+ srcs: [
+ "vk_dispatch_table_gen.py",
+ "vk_entrypoints.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "gen_enum_to_str",
+ srcs: [
+ "gen_enum_to_str.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+python_binary_host {
+ name: "vk_struct_type_cast_gen",
+ srcs: [
+ "vk_struct_type_cast_gen.py",
+ "vk_extensions.py",
+ ],
+ libs: [
+ "mako",
+ ],
+}
+
+genrule {
+ name: "vk_extensions_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_extensions.h"],
+ tools: ["vk_extensions_gen"],
+ cmd: "python3 $(location vk_extensions_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(location vk_extensions.h)",
+}
+
+genrule {
+ name: "vk_extensions_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_extensions.c"],
+ tools: ["vk_extensions_gen"],
+ cmd: "python3 $(location vk_extensions_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-c " +
+ "$(location vk_extensions.c)",
+}
+
+genrule {
+ name: "vk_dispatch_table_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_dispatch_table.h"],
+ tools: ["vk_dispatch_table_gen"],
+ cmd: "python3 $(location vk_dispatch_table_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-h " +
+ "$(location vk_dispatch_table.h) --beta false",
+}
+
+genrule {
+ name: "vk_dispatch_table_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_dispatch_table.c"],
+ tools: ["vk_dispatch_table_gen"],
+ cmd: "python3 $(location vk_dispatch_table_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --out-c " +
+ "$(location vk_dispatch_table.c) --beta false",
+}
+
+genrule {
+ name: "vk_enum_to_str_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: [
+ "vk_enum_to_str.h",
+ "vk_enum_defines.h",
+ ],
+ tools: ["gen_enum_to_str"],
+ cmd: "python3 $(location gen_enum_to_str) --xml " +
+ "$(location :libmesa_vulkan_xml) --outdir $(genDir) " +
+ "--beta false",
+}
+
+genrule {
+ name: "vk_enum_to_str_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_enum_to_str.c"],
+ tools: ["gen_enum_to_str"],
+ cmd: "python3 $(location gen_enum_to_str) --xml " +
+ "$(location :libmesa_vulkan_xml) --outdir $(genDir) " +
+ "--beta false",
+}
+
+genrule {
+ name: "vk_struct_type_cast_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["vk_struct_type_cast.h"],
+ tools: ["vk_struct_type_cast_gen"],
+ cmd: "python3 $(location vk_struct_type_cast_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --outdir $(genDir) " +
+ "--beta false",
+}
+
+cc_library_static {
+ name: "libmesa_vulkan_util_gfxstream",
+ host_supported: true,
+ vendor: true,
+ defaults: [
+ "mesa_common_defaults_gfxstream",
+ ],
+ header_libs: [
+ "mesa_common_headers_gfxstream",
+ ],
+ shared_libs: [
+ "libcutils",
+ ],
+ static_libs: [
+ "libmesa_util_gfxstream",
+ ],
+ cflags: [
+ "-DVK_NO_NIR",
+ ],
+ generated_headers: [
+ "vk_extensions_header",
+ "vk_dispatch_table_header",
+ "vk_enum_to_str_header",
+ "vk_struct_type_cast_header",
+ ],
+ generated_sources: [
+ "vk_extensions_impl",
+ "vk_dispatch_table_impl",
+ "vk_enum_to_str_impl",
+ ],
+ srcs: [
+ "vk_alloc.c",
+ "vk_format.c",
+ "vk_util.c",
+ ],
+ export_include_dirs: [
+ ".",
+ ],
+ export_generated_headers: [
+ "vk_extensions_header",
+ "vk_dispatch_table_header",
+ "vk_enum_to_str_header",
+ "vk_struct_type_cast_header",
+ ],
+}
diff --git a/guest/mesa/src/vulkan/wsi/Android.bp b/guest/mesa/src/vulkan/wsi/Android.bp
new file mode 100644
index 0000000..5c5889e
--- /dev/null
+++ b/guest/mesa/src/vulkan/wsi/Android.bp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["hardware_google_gfxstream_license"],
+}
+
+genrule {
+ name: "wsi_common_entrypoints_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["wsi_common_entrypoints.h"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(location wsi_common_entrypoints.h) --out-c " +
+ "$(genDir)/placeholder.c --prefix wsi --beta false",
+}
+
+genrule {
+ name: "wsi_common_entrypoints_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["wsi_common_entrypoints.c"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(genDir)/wsi_common_entrypoints.h --out-c " +
+ "$(location wsi_common_entrypoints.c) --prefix wsi " +
+ "--beta false",
+}
+
+cc_library_static {
+ name: "libmesa_vulkan_wsi_gfxstream",
+ host_supported: true,
+ vendor: true,
+ defaults: [
+ "mesa_common_defaults_gfxstream",
+ ],
+ header_libs: [
+ "mesa_common_headers_gfxstream",
+ ],
+ static_libs: [
+ "libmesa_vulkan_util_gfxstream",
+ "libmesa_vulkan_runtime_gfxstream",
+ "libgfxstream_guest_vulkan_entrypoints",
+ "libmesa_util_gfxstream",
+ "libdrm",
+ ],
+ shared_libs: [
+ "libcutils",
+ ],
+ cflags: [
+ "-DVK_NO_NIR",
+ ],
+ generated_headers: [
+ "vk_cmd_queue_header",
+ "vk_physical_device_features_header",
+ "vk_physical_device_properties_header",
+ "wsi_common_entrypoints_header",
+ ],
+ generated_sources: [
+ "wsi_common_entrypoints_impl",
+ ],
+ srcs: [
+ "wsi_common.c",
+ "wsi_common_drm.c",
+ "wsi_common_headless.c",
+ ],
+ export_include_dirs: [
+ ".",
+ ],
+}
diff --git a/guest/meson.build b/guest/meson.build
index bf58256..d5254ea 100644
--- a/guest/meson.build
+++ b/guest/meson.build
@@ -52,6 +52,7 @@
# Includes #
#===============#
+inc_include_mesa = include_directories('mesa/include')
inc_vulkan_headers = include_directories('../common/vulkan/include')
inc_opengl_headers = include_directories('../common/opengl/include')
inc_fuchsia_magma = include_directories('../third-party/fuchsia/magma/include')
diff --git a/guest/meson_options.txt b/guest/meson_options.txt
index c75d193..c8e94f5 100644
--- a/guest/meson_options.txt
+++ b/guest/meson_options.txt
@@ -211,7 +211,7 @@
value : ['auto'],
choices : ['auto', 'amd', 'broadcom', 'freedreno', 'intel', 'intel_hasvk',
'panfrost', 'swrast', 'virtio', 'imagination-experimental',
- 'microsoft-experimental', 'nouveau-experimental'],
+ 'microsoft-experimental', 'nouveau-experimental', 'gfxstream'],
description : 'List of vulkan drivers to build. If this is set to auto ' +
'all drivers applicable to the target OS/architecture ' +
'will be built'
diff --git a/guest/platform/Android.bp b/guest/platform/Android.bp
index fed2a4e..9ecc24e 100644
--- a/guest/platform/Android.bp
+++ b/guest/platform/Android.bp
@@ -60,7 +60,7 @@
}
}
-cc_library_static {
+cc_library_shared {
name: "libplatform_rutabaga",
host_supported: true,
vendor_available: true,
@@ -138,4 +138,4 @@
local_include_dirs: [
"include",
],
-}
\ No newline at end of file
+}
diff --git a/guest/platform/fuchsia/FuchsiaVirtGpu.h b/guest/platform/fuchsia/FuchsiaVirtGpu.h
index 357acd0..bf3089c 100644
--- a/guest/platform/fuchsia/FuchsiaVirtGpu.h
+++ b/guest/platform/fuchsia/FuchsiaVirtGpu.h
@@ -54,8 +54,7 @@
struct VirtGpuCaps getCaps(void) override;
VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createPipeBlob(uint32_t size) override;
- VirtGpuBlobPtr createPipeTexture2D(uint32_t width, uint32_t height, uint32_t format) override;
+ VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t format) override;
VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) override;
int execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob) override;
diff --git a/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp b/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
index 9f0c9ac..37ad69b 100644
--- a/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
+++ b/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
@@ -27,18 +27,13 @@
return 0;
}
-VirtGpuBlobPtr FuchsiaVirtGpuDevice::createPipeBlob(uint32_t size) {
- ALOGE("%s: unimplemented", __func__);
- return nullptr;
-}
-
VirtGpuBlobPtr FuchsiaVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
ALOGE("%s: unimplemented", __func__);
return nullptr;
}
-VirtGpuBlobPtr FuchsiaVirtGpuDevice::createPipeTexture2D(uint32_t width, uint32_t height,
- uint32_t format) {
+VirtGpuBlobPtr FuchsiaVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height,
+ uint32_t virglFormat) {
ALOGE("%s: unimplemented", __func__);
return nullptr;
}
diff --git a/guest/platform/include/VirtGpu.h b/guest/platform/include/VirtGpu.h
index f2a07b0..3f1b489 100644
--- a/guest/platform/include/VirtGpu.h
+++ b/guest/platform/include/VirtGpu.h
@@ -21,6 +21,18 @@
#include "virtgpu_gfxstream_protocol.h"
+// See virgl_hw.h and p_defines.h
+#define VIRGL_FORMAT_R8_UNORM 64
+#define VIRGL_FORMAT_B8G8R8A8_UNORM 1
+#define VIRGL_FORMAT_B5G6R5_UNORM 7
+#define VIRGL_FORMAT_R8G8B8_UNORM 66
+#define VIRGL_FORMAT_R8G8B8A8_UNORM 67
+
+#define VIRGL_BIND_RENDER_TARGET (1 << 1)
+#define VIRGL_BIND_CUSTOM (1 << 17)
+#define PIPE_BUFFER 0
+#define PIPE_TEXTURE_2D 2
+
enum VirtGpuParamId : uint32_t {
kParam3D = 0,
kParamCapsetFix = 1,
@@ -157,8 +169,7 @@
virtual struct VirtGpuCaps getCaps(void) = 0;
virtual VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) = 0;
- virtual VirtGpuBlobPtr createPipeBlob(uint32_t size) = 0;
- virtual VirtGpuBlobPtr createPipeTexture2D(uint32_t width, uint32_t height, uint32_t format) = 0;
+ virtual VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) = 0;
virtual VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) = 0;
virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob) = 0;
diff --git a/guest/platform/linux/LinuxSync.cpp b/guest/platform/linux/LinuxSync.cpp
index 7b0620d..6858c32 100644
--- a/guest/platform/linux/LinuxSync.cpp
+++ b/guest/platform/linux/LinuxSync.cpp
@@ -35,16 +35,10 @@
#endif
}
-int LinuxSyncHelper::dup(int syncFd) {
- return ::dup(syncFd);
-}
+int LinuxSyncHelper::dup(int syncFd) { return ::dup(syncFd); }
-int LinuxSyncHelper::close(int syncFd) {
- return ::close(syncFd);
-}
+int LinuxSyncHelper::close(int syncFd) { return ::close(syncFd); }
-SyncHelper* createPlatformSyncHelper() {
- return new LinuxSyncHelper();
-}
+SyncHelper* createPlatformSyncHelper() { return new LinuxSyncHelper(); }
} // namespace gfxstream
diff --git a/guest/platform/linux/LinuxVirtGpu.h b/guest/platform/linux/LinuxVirtGpu.h
index 1f8954a..8cccb0a 100644
--- a/guest/platform/linux/LinuxVirtGpu.h
+++ b/guest/platform/linux/LinuxVirtGpu.h
@@ -19,8 +19,9 @@
#include "VirtGpu.h"
class LinuxVirtGpuBlob : public std::enable_shared_from_this<LinuxVirtGpuBlob>, public VirtGpuBlob {
- public:
- LinuxVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle, uint64_t size);
+ public:
+ LinuxVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
+ uint64_t size);
~LinuxVirtGpuBlob();
uint32_t getResourceHandle(void) override;
@@ -33,7 +34,7 @@
int transferFromHost(uint32_t offset, uint32_t size) override;
int transferToHost(uint32_t offset, uint32_t size) override;
- private:
+ private:
// Not owned. Really should use a ScopedFD for this, but doesn't matter since we have a
// singleton deviceimplemenentation anyways.
int64_t mDeviceHandle;
@@ -44,20 +45,20 @@
};
class LinuxVirtGpuBlobMapping : public VirtGpuBlobMapping {
- public:
+ public:
LinuxVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size);
~LinuxVirtGpuBlobMapping(void);
uint8_t* asRawPtr(void) override;
- private:
+ private:
VirtGpuBlobPtr mBlob;
uint8_t* mPtr;
uint64_t mSize;
};
class LinuxVirtGpuDevice : public VirtGpuDevice {
- public:
+ public:
LinuxVirtGpuDevice(enum VirtGpuCapset capset, int fd = -1);
virtual ~LinuxVirtGpuDevice();
@@ -66,14 +67,12 @@
virtual struct VirtGpuCaps getCaps(void);
VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createPipeBlob(uint32_t size) override;
- VirtGpuBlobPtr createPipeTexture2D(uint32_t width, uint32_t height, uint32_t format) override;
+ VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) override;
virtual VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle);
-
virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob);
- private:
- int64_t mDeviceHandle;
- struct VirtGpuCaps mCaps;
+ private:
+ int64_t mDeviceHandle;
+ struct VirtGpuCaps mCaps;
};
diff --git a/guest/platform/linux/LinuxVirtGpuBlob.cpp b/guest/platform/linux/LinuxVirtGpuBlob.cpp
index dd1f3e1..0d5035f 100644
--- a/guest/platform/linux/LinuxVirtGpuBlob.cpp
+++ b/guest/platform/linux/LinuxVirtGpuBlob.cpp
@@ -14,20 +14,20 @@
* limitations under the License.
*/
+#include <cutils/log.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <xf86drm.h>
+
#include <cerrno>
#include <cstring>
-#include <cutils/log.h>
-
#include "LinuxVirtGpu.h"
#include "virtgpu_drm.h"
-LinuxVirtGpuBlob::LinuxVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
- uint64_t size)
+LinuxVirtGpuBlob::LinuxVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle,
+ uint32_t resourceHandle, uint64_t size)
: mDeviceHandle(deviceHandle),
mBlobHandle(blobHandle),
mResourceHandle(resourceHandle),
@@ -45,13 +45,9 @@
}
}
-uint32_t LinuxVirtGpuBlob::getBlobHandle(void) {
- return mBlobHandle;
-}
+uint32_t LinuxVirtGpuBlob::getBlobHandle(void) { return mBlobHandle; }
-uint32_t LinuxVirtGpuBlob::getResourceHandle(void) {
- return mResourceHandle;
-}
+uint32_t LinuxVirtGpuBlob::getResourceHandle(void) { return mResourceHandle; }
VirtGpuBlobMappingPtr LinuxVirtGpuBlob::createMapping(void) {
int ret;
@@ -66,7 +62,7 @@
}
uint8_t* ptr = static_cast<uint8_t*>(
- mmap64(nullptr, mSize, PROT_WRITE | PROT_READ, MAP_SHARED, mDeviceHandle, map.offset));
+ mmap64(nullptr, mSize, PROT_WRITE | PROT_READ, MAP_SHARED, mDeviceHandle, map.offset));
if (ptr == MAP_FAILED) {
ALOGE("mmap64 failed with (%s)", strerror(errno));
@@ -79,7 +75,8 @@
int LinuxVirtGpuBlob::exportBlob(struct VirtGpuExternalHandle& handle) {
int ret, fd;
- ret = drmPrimeHandleToFD(mDeviceHandle, mBlobHandle, DRM_CLOEXEC | DRM_RDWR, &fd);
+ uint32_t flags = DRM_CLOEXEC;
+ ret = drmPrimeHandleToFD(mDeviceHandle, mBlobHandle, flags, &fd);
if (ret) {
ALOGE("drmPrimeHandleToFD failed with %s", strerror(errno));
return ret;
@@ -150,4 +147,4 @@
}
return 0;
-}
\ No newline at end of file
+}
diff --git a/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp b/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp
index c8035f0..69e0e18 100644
--- a/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp
+++ b/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp
@@ -21,10 +21,6 @@
LinuxVirtGpuBlobMapping::LinuxVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size)
: mBlob(blob), mPtr(ptr), mSize(size) {}
-LinuxVirtGpuBlobMapping::~LinuxVirtGpuBlobMapping(void) {
- munmap(mPtr, mSize);
-}
+LinuxVirtGpuBlobMapping::~LinuxVirtGpuBlobMapping(void) { munmap(mPtr, mSize); }
-uint8_t* LinuxVirtGpuBlobMapping::asRawPtr(void) {
- return mPtr;
-}
+uint8_t* LinuxVirtGpuBlobMapping::asRawPtr(void) { return mPtr; }
diff --git a/guest/platform/linux/LinuxVirtGpuDevice.cpp b/guest/platform/linux/LinuxVirtGpuDevice.cpp
index 0df712b..9e35cdb 100644
--- a/guest/platform/linux/LinuxVirtGpuDevice.cpp
+++ b/guest/platform/linux/LinuxVirtGpuDevice.cpp
@@ -34,10 +34,14 @@
#define PARAM(x) \
(struct VirtGpuParam) { x, #x, 0 }
-// See virgl_hw.h and p_defines.h
-#define VIRGL_FORMAT_R8_UNORM 64
-#define VIRGL_BIND_CUSTOM (1 << 17)
-#define PIPE_BUFFER 0
+#if defined(PAGE_SIZE) && defined(VIRTIO_GPU)
+constexpr size_t kPageSize = PAGE_SIZE;
+#else
+#include <unistd.h>
+static const size_t kPageSize = getpagesize();
+#endif
+
+static inline uint32_t align_up(uint32_t n, uint32_t a) { return ((n + a - 1) / a) * a; }
LinuxVirtGpuDevice::LinuxVirtGpuDevice(enum VirtGpuCapset capset, int fd) : VirtGpuDevice(capset) {
struct VirtGpuParam params[] = {
@@ -52,7 +56,7 @@
struct drm_virtgpu_get_caps get_caps = {0};
struct drm_virtgpu_context_init init = {0};
struct drm_virtgpu_context_set_param ctx_set_params[3] = {{0}};
- const char *processName = nullptr;
+ const char* processName = nullptr;
memset(&mCaps, 0, sizeof(struct VirtGpuCaps));
@@ -142,31 +146,51 @@
ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_CONTEXT_INIT, &init);
if (ret) {
ALOGE("DRM_IOCTL_VIRTGPU_CONTEXT_INIT failed with %s, continuing without context...",
- strerror(errno));
+ strerror(errno));
}
}
-LinuxVirtGpuDevice::~LinuxVirtGpuDevice() {
- close(mDeviceHandle);
-}
+LinuxVirtGpuDevice::~LinuxVirtGpuDevice() { close(mDeviceHandle); }
struct VirtGpuCaps LinuxVirtGpuDevice::getCaps(void) { return mCaps; }
-int64_t LinuxVirtGpuDevice::getDeviceHandle(void) {
- return mDeviceHandle;
-}
+int64_t LinuxVirtGpuDevice::getDeviceHandle(void) { return mDeviceHandle; }
-VirtGpuBlobPtr LinuxVirtGpuDevice::createPipeBlob(uint32_t size) {
+VirtGpuBlobPtr LinuxVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height,
+ uint32_t virglFormat) {
+ uint32_t target = 0;
+ uint32_t bind = 0;
+ uint32_t bpp = 0;
+
+ switch (virglFormat) {
+ case VIRGL_FORMAT_R8G8B8A8_UNORM:
+ case VIRGL_FORMAT_B8G8R8A8_UNORM:
+ target = PIPE_TEXTURE_2D;
+ bind = VIRGL_BIND_RENDER_TARGET;
+ bpp = 4;
+ break;
+ case VIRGL_FORMAT_R8_UNORM:
+ target = PIPE_BUFFER;
+ bind = VIRGL_BIND_CUSTOM;
+ bpp = 1;
+ break;
+ default:
+ ALOGE("Unknown virgl format");
+ return nullptr;
+ }
+
drm_virtgpu_resource_create create = {
- .target = PIPE_BUFFER,
- .format = VIRGL_FORMAT_R8_UNORM,
- .bind = VIRGL_BIND_CUSTOM,
- .width = size,
- .height = 1U,
- .depth = 1U,
- .array_size = 0U,
- .size = size,
- .stride = size,
+ .target = target,
+ .format = virglFormat,
+ .bind = bind,
+ .width = width,
+ .height = height,
+ .depth = 1U,
+ .array_size = 1U,
+ .last_level = 0,
+ .nr_samples = 0,
+ .size = width * height * bpp,
+ .stride = width * bpp,
};
int ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
@@ -176,7 +200,7 @@
}
return std::make_shared<LinuxVirtGpuBlob>(mDeviceHandle, create.bo_handle, create.res_handle,
- static_cast<uint64_t>(size));
+ static_cast<uint64_t>(create.size));
}
VirtGpuBlobPtr LinuxVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
@@ -195,12 +219,7 @@
}
return std::make_shared<LinuxVirtGpuBlob>(mDeviceHandle, create.bo_handle, create.res_handle,
- blobCreate.size);
-}
-
-VirtGpuBlobPtr LinuxVirtGpuDevice::createPipeTexture2D(uint32_t, uint32_t, uint32_t) {
- ALOGE("Unimplemented LinuxVirtGpuDevice::createPipeTexture2D().");
- return nullptr;
+ blobCreate.size);
}
VirtGpuBlobPtr LinuxVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle& handle) {
@@ -223,7 +242,7 @@
}
return std::make_shared<LinuxVirtGpuBlob>(mDeviceHandle, blobHandle, info.res_handle,
- static_cast<uint64_t>(info.size));
+ static_cast<uint64_t>(info.size));
}
int LinuxVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob) {
diff --git a/guest/platform/rutabaga/RutabagaLayer.cpp b/guest/platform/rutabaga/RutabagaLayer.cpp
index b6d569e..42fb57d 100644
--- a/guest/platform/rutabaga/RutabagaLayer.cpp
+++ b/guest/platform/rutabaga/RutabagaLayer.cpp
@@ -14,11 +14,13 @@
* limitations under the License.
*/
- #include "RutabagaLayer.h"
+#include "RutabagaLayer.h"
+
+#include <inttypes.h>
+#include <log/log.h>
#include <cstdlib>
#include <future>
-#include <inttypes.h>
#include <memory>
#include <optional>
#include <queue>
@@ -28,17 +30,15 @@
#include <unordered_map>
#include <variant>
-#include <log/log.h>
-
#include "gfxstream/virtio-gpu-gfxstream-renderer.h"
+#include "gfxstream/virtio-gpu-gfxstream-renderer-unstable.h"
namespace gfxstream {
namespace {
constexpr const uint32_t kInvalidContextId = 0;
-std::vector<std::string> Split(const std::string& s,
- const std::string& delimiters) {
+std::vector<std::string> Split(const std::string& s, const std::string& delimiters) {
if (delimiters.empty()) {
return {};
}
@@ -50,16 +50,14 @@
while (true) {
found = s.find_first_of(delimiters, base);
result.push_back(s.substr(base, found - base));
- if (found == s.npos)
- break;
+ if (found == s.npos) break;
base = found + 1;
}
return result;
}
-std::string Join(const std::vector<std::string>& things,
- const std::string& separator) {
+std::string Join(const std::vector<std::string>& things, const std::string& separator) {
if (things.empty()) {
return "";
}
@@ -75,14 +73,11 @@
} // namespace
class EmulatedVirtioGpu::EmulatedVirtioGpuImpl {
- public:
+ public:
EmulatedVirtioGpuImpl();
~EmulatedVirtioGpuImpl();
- bool Init(bool withGl,
- bool withVk,
- bool withVkSnapshots,
- EmulatedVirtioGpu* parent);
+ bool Init(bool withGl, bool withVk, bool withVkSnapshots, EmulatedVirtioGpu* parent);
VirtGpuCaps GetCaps(VirtGpuCapset capset);
@@ -92,32 +87,21 @@
uint8_t* Map(uint32_t resourceId);
void Unmap(uint32_t resourceId);
- int ExecBuffer(uint32_t contextId,
- struct VirtGpuExecBuffer& execbuffer,
+ int ExecBuffer(uint32_t contextId, struct VirtGpuExecBuffer& execbuffer,
std::optional<uint32_t> blobResourceId);
int Wait(uint32_t resourceId);
- int TransferFromHost(uint32_t contextId,
- uint32_t resourceId,
- uint32_t transferOffset,
+ int TransferFromHost(uint32_t contextId, uint32_t resourceId, uint32_t transferOffset,
uint32_t transferSize);
- int TransferToHost(uint32_t contextId,
- uint32_t resourceId,
- uint32_t transferOffset,
+ int TransferToHost(uint32_t contextId, uint32_t resourceId, uint32_t transferOffset,
uint32_t transferSize);
- std::optional<uint32_t> CreateBlob(uint32_t contextId,
- const struct VirtGpuCreateBlob& params);
- std::optional<uint32_t> CreatePipeBlob(uint32_t contextId,
- uint32_t size);
- std::optional<uint32_t> CreatePipeTexture2D(uint32_t contextId,
- uint32_t width,
- uint32_t height,
- uint32_t format);
+ std::optional<uint32_t> CreateBlob(uint32_t contextId, const struct VirtGpuCreateBlob& params);
+ std::optional<uint32_t> CreateVirglBlob(uint32_t contextId, uint32_t width, uint32_t height,
+ uint32_t virglFormat);
- void DestroyResource(uint32_t contextId,
- uint32_t resourceId);
+ void DestroyResource(uint32_t contextId, uint32_t resourceId);
uint32_t CreateEmulatedFence();
@@ -125,7 +109,7 @@
int WaitOnEmulatedFence(int fenceAsFileDescriptor, int timeoutMilliseconds);
- private:
+ private:
struct VirtioGpuTaskContextAttachResource {
uint32_t contextId;
uint32_t resourceId;
@@ -176,17 +160,12 @@
struct VirtioGpuTaskUnrefResource {
uint32_t resourceId;
};
- using VirtioGpuTask = std::variant<VirtioGpuTaskContextAttachResource,
- VirtioGpuTaskContextDetachResource,
- VirtioGpuTaskCreateBlob,
- VirtioGpuTaskCreateContext,
- VirtioGpuTaskCreateResource,
- VirtioGpuTaskDestroyContext,
- VirtioGpuTaskMap,
- VirtioGpuTaskExecBuffer,
- VirtioGpuTaskTransferFromHost,
- VirtioGpuTaskTransferToHost,
- VirtioGpuTaskUnrefResource>;
+ using VirtioGpuTask =
+ std::variant<VirtioGpuTaskContextAttachResource, VirtioGpuTaskContextDetachResource,
+ VirtioGpuTaskCreateBlob, VirtioGpuTaskCreateContext,
+ VirtioGpuTaskCreateResource, VirtioGpuTaskDestroyContext, VirtioGpuTaskMap,
+ VirtioGpuTaskExecBuffer, VirtioGpuTaskTransferFromHost,
+ VirtioGpuTaskTransferToHost, VirtioGpuTaskUnrefResource>;
struct VirtioGpuTaskWithWaitable {
uint32_t contextId;
VirtioGpuTask task;
@@ -194,8 +173,7 @@
std::optional<uint32_t> fence;
};
- std::shared_future<void> EnqueueVirtioGpuTask(uint32_t contextId,
- VirtioGpuTask task,
+ std::shared_future<void> EnqueueVirtioGpuTask(uint32_t contextId, VirtioGpuTask task,
std::optional<uint32_t> fence = std::nullopt);
void DoTask(VirtioGpuTaskContextAttachResource task);
void DoTask(VirtioGpuTaskContextDetachResource task);
@@ -243,9 +221,8 @@
EmulatedResource* CreateResource(uint32_t resourceId, EmulatedResourceType resourceType) {
std::lock_guard<std::mutex> lock(mResourcesMutex);
- auto [it, created] = mResources.emplace(std::piecewise_construct,
- std::forward_as_tuple(resourceId),
- std::forward_as_tuple());
+ auto [it, created] = mResources.emplace(
+ std::piecewise_construct, std::forward_as_tuple(resourceId), std::forward_as_tuple());
if (!created) {
ALOGE("Created resource %" PRIu32 " twice?", resourceId);
}
@@ -300,9 +277,7 @@
} // namespace
-bool EmulatedVirtioGpu::EmulatedVirtioGpuImpl::Init(bool withGl,
- bool withVk,
- bool withVkSnapshots,
+bool EmulatedVirtioGpu::EmulatedVirtioGpuImpl::Init(bool withGl, bool withVk, bool withVkSnapshots,
EmulatedVirtioGpu* parent) {
std::vector<stream_renderer_param> renderer_params{
stream_renderer_param{
@@ -317,10 +292,12 @@
.key = STREAM_RENDERER_PARAM_RENDERER_FLAGS,
.value =
static_cast<uint64_t>(STREAM_RENDERER_FLAGS_USE_SURFACELESS_BIT) |
- (withGl ? static_cast<uint64_t>(STREAM_RENDERER_FLAGS_USE_EGL_BIT |
- STREAM_RENDERER_FLAGS_USE_GLES_BIT) : 0 ) |
- (withVk ? static_cast<uint64_t>(STREAM_RENDERER_FLAGS_USE_VK_BIT) : 0 ) |
- (withVkSnapshots ? static_cast<uint64_t>(STREAM_RENDERER_FLAGS_VULKAN_SNAPSHOTS): 0),
+ (withGl ? static_cast<uint64_t>(STREAM_RENDERER_FLAGS_USE_EGL_BIT |
+ STREAM_RENDERER_FLAGS_USE_GLES_BIT)
+ : 0) |
+ (withVk ? static_cast<uint64_t>(STREAM_RENDERER_FLAGS_USE_VK_BIT) : 0) |
+ (withVkSnapshots ? static_cast<uint64_t>(STREAM_RENDERER_FLAGS_VULKAN_SNAPSHOTS)
+ : 0),
},
stream_renderer_param{
.key = STREAM_RENDERER_PARAM_WIN0_WIDTH,
@@ -336,16 +313,17 @@
VirtGpuCaps EmulatedVirtioGpu::EmulatedVirtioGpuImpl::GetCaps(VirtGpuCapset capset) {
VirtGpuCaps caps = {
- .params = {
- [kParam3D] = 1,
- [kParamCapsetFix] = 1,
- [kParamResourceBlob] = 1,
- [kParamHostVisible] = 1,
- [kParamCrossDevice] = 0,
- [kParamContextInit] = 1,
- [kParamSupportedCapsetIds] = 0,
- [kParamCreateGuestHandle] = 0,
- },
+ .params =
+ {
+ [kParam3D] = 1,
+ [kParamCapsetFix] = 1,
+ [kParamResourceBlob] = 1,
+ [kParamHostVisible] = 1,
+ [kParamCrossDevice] = 0,
+ [kParamContextInit] = 1,
+ [kParamSupportedCapsetIds] = 0,
+ [kParamCreateGuestHandle] = 0,
+ },
};
stream_renderer_fill_caps(static_cast<uint32_t>(capset), 0, &caps.vulkanCapset);
@@ -382,8 +360,10 @@
uint8_t* mapped = nullptr;
if (resource->type == EmulatedResourceType::kBlob) {
if (!resource->mappedHostBytes.valid()) {
- ALOGE("Failed to Map() resource %" PRIu32 ": attempting to map blob "
- "without mappable flag?", resourceId);
+ ALOGE("Failed to Map() resource %" PRIu32
+ ": attempting to map blob "
+ "without mappable flag?",
+ resourceId);
return nullptr;
}
mapped = resource->mappedHostBytes.get();
@@ -417,11 +397,10 @@
return 0;
}
-int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::TransferFromHost(
- uint32_t contextId,
- uint32_t resourceId,
- uint32_t transferOffset,
- uint32_t transferSize) {
+int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::TransferFromHost(uint32_t contextId,
+ uint32_t resourceId,
+ uint32_t transferOffset,
+ uint32_t transferSize) {
EmulatedResource* resource = GetResource(resourceId);
if (resource == nullptr) {
ALOGE("Failed to TransferFromHost() on resource %" PRIu32 ": not found.", resourceId);
@@ -444,11 +423,10 @@
return 0;
}
-int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::TransferToHost(
- uint32_t contextId,
- uint32_t resourceId,
- uint32_t transferOffset,
- uint32_t transferSize) {
+int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::TransferToHost(uint32_t contextId,
+ uint32_t resourceId,
+ uint32_t transferOffset,
+ uint32_t transferSize) {
EmulatedResource* resource = GetResource(resourceId);
if (resource == nullptr) {
ALOGE("Failed to TransferFromHost() on resource %" PRIu32 ": not found.", resourceId);
@@ -472,8 +450,8 @@
}
std::optional<uint32_t> EmulatedVirtioGpu::EmulatedVirtioGpuImpl::CreateBlob(
- uint32_t contextId,
- const struct VirtGpuCreateBlob& blobCreate) {
+ uint32_t contextId, const struct VirtGpuCreateBlob& blobCreate) {
+
const uint32_t resourceId = mNextVirtioGpuResourceId++;
ALOGV("Enquing task to create blob resource-id:%d size:%" PRIu64, resourceId, blobCreate.size);
@@ -483,12 +461,13 @@
VirtioGpuTaskCreateBlob createTask{
.contextId = contextId,
.resourceId = resourceId,
- .params = {
- .blob_mem = static_cast<uint32_t>(blobCreate.blobMem),
- .blob_flags = static_cast<uint32_t>(blobCreate.flags),
- .blob_id = blobCreate.blobId,
- .size = blobCreate.size,
- },
+ .params =
+ {
+ .blob_mem = static_cast<uint32_t>(blobCreate.blobMem),
+ .blob_flags = static_cast<uint32_t>(blobCreate.flags),
+ .blob_id = blobCreate.blobId,
+ .size = blobCreate.size,
+ },
};
auto createBlobCompletedWaitable = EnqueueVirtioGpuTask(contextId, std::move(createTask));
resource->pendingWaitables.push_back(std::move(createBlobCompletedWaitable));
@@ -514,71 +493,64 @@
return resourceId;
}
-std::optional<uint32_t> EmulatedVirtioGpu::EmulatedVirtioGpuImpl::CreatePipeBlob(
- uint32_t contextId,
- uint32_t size) {
+std::optional<uint32_t> EmulatedVirtioGpu::EmulatedVirtioGpuImpl::CreateVirglBlob(
+ uint32_t contextId, uint32_t width, uint32_t height, uint32_t virglFormat) {
+
const uint32_t resourceId = mNextVirtioGpuResourceId++;
EmulatedResource* resource = CreateResource(resourceId, EmulatedResourceType::kPipe);
- resource->guestBytes = std::make_unique<uint8_t[]>(size);
+
+ uint32_t target = 0;
+ uint32_t bind = 0;
+ uint32_t bpp = 0;
+
+ switch (virglFormat) {
+ case VIRGL_FORMAT_R8G8B8A8_UNORM:
+ case VIRGL_FORMAT_B8G8R8A8_UNORM:
+ target = PIPE_TEXTURE_2D;
+ bind = VIRGL_BIND_RENDER_TARGET;
+ bpp = 4;
+ break;
+ case VIRGL_FORMAT_B5G6R5_UNORM:
+ target = PIPE_TEXTURE_2D;
+ bind = VIRGL_BIND_RENDER_TARGET;
+ bpp = 2;
+ break;
+ case VIRGL_FORMAT_R8G8B8_UNORM:
+ target = PIPE_TEXTURE_2D;
+ bind = VIRGL_BIND_RENDER_TARGET;
+ bpp = 3;
+ break;
+ case VIRGL_FORMAT_R8_UNORM:
+ target = PIPE_BUFFER;
+ bind = VIRGL_BIND_CUSTOM;
+ bpp = 1;
+ break;
+ default:
+ ALOGE("Unknown virgl format %u", virglFormat);
+ return {};
+ }
+
+ resource->guestBytes = std::make_unique<uint8_t[]>(width * height * bpp);
VirtioGpuTaskCreateResource task{
.contextId = contextId,
.resourceId = resourceId,
.resourceBytes = resource->guestBytes.get(),
- .params = {
- .handle = resourceId,
- .target = /*PIPE_BUFFER=*/0,
- .format = /*VIRGL_FORMAT_R8_UNORM=*/64,
- .bind = /*VIRGL_BIND_CUSTOM=*/(1 << 17),
- .width = size,
- .height = 1,
- .depth = 1,
- .array_size = 0,
- .last_level = 0,
- .nr_samples = 0,
- .flags = 0,
- },
- };
- auto taskCompletedWaitable = EnqueueVirtioGpuTask(contextId, std::move(task));
- resource->pendingWaitables.push_back(std::move(taskCompletedWaitable));
-
- VirtioGpuTaskContextAttachResource attachTask{
- .contextId = contextId,
- .resourceId = resourceId,
- };
- EnqueueVirtioGpuTask(contextId, std::move(attachTask));
-
- return resourceId;
-}
-
-std::optional<uint32_t> EmulatedVirtioGpu::EmulatedVirtioGpuImpl::CreatePipeTexture2D(
- uint32_t contextId,
- uint32_t width,
- uint32_t height,
- uint32_t format) {
- const uint32_t resourceId = mNextVirtioGpuResourceId++;
-
- EmulatedResource* resource = CreateResource(resourceId, EmulatedResourceType::kPipe);
- resource->guestBytes = std::make_unique<uint8_t[]>(width * height * 4);
-
- VirtioGpuTaskCreateResource task{
- .contextId = contextId,
- .resourceId = resourceId,
- .resourceBytes = resource->guestBytes.get(),
- .params = {
- .handle = resourceId,
- .target = /*PIPE_TEXTURE_2D=*/2,
- .format = format,
- .bind = 0,
- .width = width,
- .height = height,
- .depth = 1,
- .array_size = 1,
- .last_level = 0,
- .nr_samples = 0,
- .flags = 0,
- },
+ .params =
+ {
+ .handle = resourceId,
+ .target = target,
+ .format = virglFormat,
+ .bind = bind,
+ .width = width,
+ .height = height,
+ .depth = 1,
+ .array_size = 1,
+ .last_level = 0,
+ .nr_samples = 0,
+ .flags = 0,
+ },
};
auto taskCompletedWaitable = EnqueueVirtioGpuTask(contextId, std::move(task));
resource->pendingWaitables.push_back(std::move(taskCompletedWaitable));
@@ -608,10 +580,9 @@
EnqueueVirtioGpuTask(contextId, std::move(detachTask));
}
-int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::ExecBuffer(
- uint32_t contextId,
- struct VirtGpuExecBuffer& execbuffer,
- std::optional<uint32_t> blobResourceId) {
+int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::ExecBuffer(uint32_t contextId,
+ struct VirtGpuExecBuffer& execbuffer,
+ std::optional<uint32_t> blobResourceId) {
std::optional<uint32_t> fence;
if (execbuffer.flags & kFenceOut) {
@@ -647,9 +618,8 @@
return 0;
}
-int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::WaitOnEmulatedFence(
- int fenceAsFileDescriptor,
- int timeoutMilliseconds) {
+int EmulatedVirtioGpu::EmulatedVirtioGpuImpl::WaitOnEmulatedFence(int fenceAsFileDescriptor,
+ int timeoutMilliseconds) {
uint32_t fenceId = static_cast<uint32_t>(fenceAsFileDescriptor);
ALOGV("Waiting on fence:%d", (int)fenceId);
@@ -711,50 +681,45 @@
}
std::shared_future<void> EmulatedVirtioGpu::EmulatedVirtioGpuImpl::EnqueueVirtioGpuTask(
- uint32_t contextId,
- VirtioGpuTask task,
- std::optional<uint32_t> fence) {
+ uint32_t contextId, VirtioGpuTask task, std::optional<uint32_t> fence) {
std::promise<void> taskCompletedSignaler;
std::shared_future<void> taskCompletedWaitable(taskCompletedSignaler.get_future());
std::lock_guard<std::mutex> lock(mTasksMutex);
- mTasks.push(
- VirtioGpuTaskWithWaitable{
- .contextId = contextId,
- .task = std::move(task),
- .taskCompletedSignaler = std::move(taskCompletedSignaler),
- .fence = fence,
- });
+ mTasks.push(VirtioGpuTaskWithWaitable{
+ .contextId = contextId,
+ .task = std::move(task),
+ .taskCompletedSignaler = std::move(taskCompletedSignaler),
+ .fence = fence,
+ });
return taskCompletedWaitable;
}
void EmulatedVirtioGpu::EmulatedVirtioGpuImpl::DoTask(VirtioGpuTaskContextAttachResource task) {
- ALOGV("Performing task to attach resource-id:%d to context-id:%d",
- task.resourceId, task.contextId);
+ ALOGV("Performing task to attach resource-id:%d to context-id:%d", task.resourceId,
+ task.contextId);
stream_renderer_ctx_attach_resource(task.contextId, task.resourceId);
- ALOGV("Performing task to attach resource-id:%d to context-id:%d - done",
- task.resourceId, task.contextId);
+ ALOGV("Performing task to attach resource-id:%d to context-id:%d - done", task.resourceId,
+ task.contextId);
}
void EmulatedVirtioGpu::EmulatedVirtioGpuImpl::DoTask(VirtioGpuTaskContextDetachResource task) {
- ALOGV("Performing task to detach resource-id:%d to context-id:%d",
- task.resourceId, task.contextId);
+ ALOGV("Performing task to detach resource-id:%d to context-id:%d", task.resourceId,
+ task.contextId);
stream_renderer_ctx_detach_resource(task.contextId, task.resourceId);
- ALOGV("Performing task to detach resource-id:%d to context-id:%d - done",
- task.resourceId, task.contextId);
+ ALOGV("Performing task to detach resource-id:%d to context-id:%d - done", task.resourceId,
+ task.contextId);
}
void EmulatedVirtioGpu::EmulatedVirtioGpuImpl::DoTask(VirtioGpuTaskCreateBlob task) {
ALOGV("Performing task to create blob resource-id:%d", task.resourceId);
- int ret = stream_renderer_create_blob(task.contextId,
- task.resourceId,
- &task.params,
+ int ret = stream_renderer_create_blob(task.contextId, task.resourceId, &task.params,
/*iovecs=*/nullptr,
/*num_iovs=*/0,
/*handle=*/nullptr);
@@ -770,10 +735,8 @@
" context-name:%s",
task.contextId, task.contextInit, task.contextName.c_str());
- int ret = stream_renderer_context_create(task.contextId,
- task.contextName.size(),
- task.contextName.data(),
- task.contextInit);
+ int ret = stream_renderer_context_create(task.contextId, task.contextName.size(),
+ task.contextName.data(), task.contextInit);
if (ret) {
ALOGE("Failed to create context-id:%" PRIu32 ".", task.contextId);
return;
@@ -863,12 +826,10 @@
.d = 1,
};
- int ret = stream_renderer_transfer_read_iov(task.resourceId,
- task.contextId,
+ int ret = stream_renderer_transfer_read_iov(task.resourceId, task.contextId,
/*level=*/0,
/*stride=*/0,
- /*layer_stride=*/0,
- &transferBox,
+ /*layer_stride=*/0, &transferBox,
/*offset=*/0,
/*iov=*/nullptr,
/*iovec_cnt=*/0);
@@ -887,12 +848,10 @@
.d = 1,
};
- int ret = stream_renderer_transfer_write_iov(task.resourceId,
- task.contextId,
+ int ret = stream_renderer_transfer_write_iov(task.resourceId, task.contextId,
/*level=*/0,
/*stride=*/0,
- /*layer_stride=*/0,
- &transferBox,
+ /*layer_stride=*/0, &transferBox,
/*offset=*/0,
/*iov=*/nullptr,
/*iovec_cnt=*/0);
@@ -907,7 +866,7 @@
void EmulatedVirtioGpu::EmulatedVirtioGpuImpl::DoTask(VirtioGpuTaskWithWaitable task) {
std::visit(
- [this](auto&& work){
+ [this](auto&& work) {
using T = std::decay_t<decltype(work)>;
if constexpr (std::is_same_v<T, VirtioGpuTaskContextAttachResource>) {
DoTask(std::move(work));
@@ -932,7 +891,8 @@
} else if constexpr (std::is_same_v<T, VirtioGpuTaskUnrefResource>) {
DoTask(std::move(work));
}
- }, task.task);
+ },
+ task.task);
if (task.fence) {
const stream_renderer_fence fenceInfo = {
@@ -1002,8 +962,8 @@
}
}
- ALOGE("Initializing withGl:%d withVk:%d withVkSnapshots:%d",
- withGl, withVk, withVkSnapshots);
+ ALOGE("Initializing withGl:%d withVk:%d withVkSnapshots:%d", withGl, withVk,
+ withVkSnapshots);
if (!sInstance->Init(withGl, withVk, withVkSnapshots)) {
ALOGE("Failed to initialize EmulatedVirtioGpu.");
}
@@ -1023,46 +983,29 @@
return mImpl->Init(withGl, withVk, withVkSnapshots, this);
}
-std::optional<uint32_t> EmulatedVirtioGpu::CreateContext() {
- return mImpl->CreateContext();
-}
+std::optional<uint32_t> EmulatedVirtioGpu::CreateContext() { return mImpl->CreateContext(); }
-void EmulatedVirtioGpu::DestroyContext(uint32_t contextId) {
- mImpl->DestroyContext(contextId);
-}
+void EmulatedVirtioGpu::DestroyContext(uint32_t contextId) { mImpl->DestroyContext(contextId); }
-VirtGpuCaps EmulatedVirtioGpu::GetCaps(VirtGpuCapset capset) {
- return mImpl->GetCaps(capset);
-}
+VirtGpuCaps EmulatedVirtioGpu::GetCaps(VirtGpuCapset capset) { return mImpl->GetCaps(capset); }
-uint8_t* EmulatedVirtioGpu::Map(uint32_t resourceId) {
- return mImpl->Map(resourceId);
-}
+uint8_t* EmulatedVirtioGpu::Map(uint32_t resourceId) { return mImpl->Map(resourceId); }
-void EmulatedVirtioGpu::Unmap(uint32_t resourceId) {
- mImpl->Unmap(resourceId);
-}
+void EmulatedVirtioGpu::Unmap(uint32_t resourceId) { mImpl->Unmap(resourceId); }
-int EmulatedVirtioGpu::ExecBuffer(uint32_t contextId,
- struct VirtGpuExecBuffer& execbuffer,
+int EmulatedVirtioGpu::ExecBuffer(uint32_t contextId, struct VirtGpuExecBuffer& execbuffer,
std::optional<uint32_t> blobResourceId) {
return mImpl->ExecBuffer(contextId, execbuffer, blobResourceId);
}
-int EmulatedVirtioGpu::Wait(uint32_t resourceId) {
- return mImpl->Wait(resourceId);
-}
+int EmulatedVirtioGpu::Wait(uint32_t resourceId) { return mImpl->Wait(resourceId); }
-int EmulatedVirtioGpu::TransferFromHost(uint32_t contextId,
- uint32_t resourceId,\
- uint32_t offset,
+int EmulatedVirtioGpu::TransferFromHost(uint32_t contextId, uint32_t resourceId, uint32_t offset,
uint32_t size) {
return mImpl->TransferFromHost(contextId, resourceId, offset, size);
}
-int EmulatedVirtioGpu::TransferToHost(uint32_t contextId,
- uint32_t resourceId,
- uint32_t offset,
+int EmulatedVirtioGpu::TransferToHost(uint32_t contextId, uint32_t resourceId, uint32_t offset,
uint32_t size) {
return mImpl->TransferToHost(contextId, resourceId, offset, size);
}
@@ -1072,17 +1015,9 @@
return mImpl->CreateBlob(contextId, params);
}
-std::optional<uint32_t> EmulatedVirtioGpu::CreatePipeBlob(uint32_t contextId,
- uint32_t size) {
- return mImpl->CreatePipeBlob(contextId, size);
-}
-
-std::optional<uint32_t> EmulatedVirtioGpu::CreatePipeTexture2D(
- uint32_t contextId,
- uint32_t width,
- uint32_t height,
- uint32_t format) {
- return mImpl->CreatePipeTexture2D(contextId, width, height, format);
+std::optional<uint32_t> EmulatedVirtioGpu::CreateVirglBlob(uint32_t contextId, uint32_t width,
+ uint32_t height, uint32_t virglFormat) {
+ return mImpl->CreateVirglBlob(contextId, width, height, virglFormat);
}
void EmulatedVirtioGpu::DestroyResource(uint32_t contextId, uint32_t resourceId) {
@@ -1093,12 +1028,8 @@
return mImpl->WaitOnEmulatedFence(fenceAsFileDescriptor, timeoutMilliseconds);
}
-void EmulatedVirtioGpu::SignalEmulatedFence(int fenceId) {
- mImpl->SignalEmulatedFence(fenceId);
-}
+void EmulatedVirtioGpu::SignalEmulatedFence(int fenceId) { mImpl->SignalEmulatedFence(fenceId); }
-void ResetEmulatedVirtioGpu() {
- EmulatedVirtioGpu::Reset();
-}
+void ResetEmulatedVirtioGpu() { EmulatedVirtioGpu::Reset(); }
} // namespace gfxstream
diff --git a/guest/platform/rutabaga/RutabagaLayer.h b/guest/platform/rutabaga/RutabagaLayer.h
index 92c69bf..057b2f7 100644
--- a/guest/platform/rutabaga/RutabagaLayer.h
+++ b/guest/platform/rutabaga/RutabagaLayer.h
@@ -38,14 +38,12 @@
std::optional<uint32_t> CreateContext();
void DestroyContext(uint32_t contextId);
- std::optional<uint32_t> CreatePipeBlob(uint32_t contextId,
- uint32_t size);
std::optional<uint32_t> CreateBlob(uint32_t contextId,
const struct VirtGpuCreateBlob& params);
- std::optional<uint32_t> CreatePipeTexture2D(uint32_t contextId,
- uint32_t width,
- uint32_t height,
- uint32_t format);
+ std::optional<uint32_t> CreateVirglBlob(uint32_t contextId,
+ uint32_t width,
+ uint32_t height,
+ uint32_t virglFormat);
void DestroyResource(uint32_t contextId,
uint32_t resourceId);
@@ -79,4 +77,4 @@
std::unique_ptr<EmulatedVirtioGpuImpl> mImpl;
};
-} // namespace gfxstream
\ No newline at end of file
+} // namespace gfxstream
diff --git a/guest/platform/rutabaga/RutabagaVirtGpu.h b/guest/platform/rutabaga/RutabagaVirtGpu.h
index b977d37..0abea2b 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpu.h
+++ b/guest/platform/rutabaga/RutabagaVirtGpu.h
@@ -82,9 +82,7 @@
VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createPipeBlob(uint32_t size) override;
-
- VirtGpuBlobPtr createPipeTexture2D(uint32_t width, uint32_t height, uint32_t format) override;
+ VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) override;
VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) override;
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp b/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp
index 256f87b..2799b74 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp
@@ -14,21 +14,16 @@
* limitations under the License.
*/
-#include "RutabagaVirtGpu.h"
-
#include <log/log.h>
#include "RutabagaLayer.h"
+#include "RutabagaVirtGpu.h"
namespace gfxstream {
-RutabagaVirtGpuResource::RutabagaVirtGpuResource(
- uint32_t resourceId,
- ResourceType resourceType,
- uint32_t contextId)
- : mContextId(contextId),
- mResourceId(resourceId),
- mResourceType(resourceType) {}
+RutabagaVirtGpuResource::RutabagaVirtGpuResource(uint32_t resourceId, ResourceType resourceType,
+ uint32_t contextId)
+ : mContextId(contextId), mResourceId(resourceId), mResourceType(resourceType) {}
RutabagaVirtGpuResource::~RutabagaVirtGpuResource() {
EmulatedVirtioGpu::Get().DestroyResource(mContextId, mResourceId);
@@ -39,9 +34,7 @@
return std::make_shared<RutabagaVirtGpuBlobMapping>(shared_from_this(), mapped);
}
-uint32_t RutabagaVirtGpuResource::getResourceHandle() {
- return mResourceId;
-}
+uint32_t RutabagaVirtGpuResource::getResourceHandle() { return mResourceId; }
uint32_t RutabagaVirtGpuResource::getBlobHandle() {
if (mResourceType != ResourceType::kBlob) {
@@ -63,9 +56,7 @@
return -1;
}
-int RutabagaVirtGpuResource::wait() {
- return EmulatedVirtioGpu::Get().Wait(mResourceId);
-}
+int RutabagaVirtGpuResource::wait() { return EmulatedVirtioGpu::Get().Wait(mResourceId); }
int RutabagaVirtGpuResource::transferFromHost(uint32_t offset, uint32_t size) {
if (mResourceType != ResourceType::kPipe) {
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp b/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp
index 8aac819..4f82f7c 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp
@@ -14,15 +14,13 @@
* limitations under the License.
*/
-#include "RutabagaVirtGpu.h"
-
#include "RutabagaLayer.h"
+#include "RutabagaVirtGpu.h"
namespace gfxstream {
RutabagaVirtGpuBlobMapping::RutabagaVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* mapped)
- : mBlob(blob),
- mMapped(mapped) {}
+ : mBlob(blob), mMapped(mapped) {}
RutabagaVirtGpuBlobMapping::~RutabagaVirtGpuBlobMapping(void) {
EmulatedVirtioGpu::Get().Unmap(mBlob->getResourceHandle());
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp b/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
index 5d59e51..4263288 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
@@ -14,28 +14,24 @@
* limitations under the License.
*/
-#include "RutabagaVirtGpu.h"
-
#include <log/log.h>
#include "RutabagaLayer.h"
+#include "RutabagaVirtGpu.h"
namespace gfxstream {
RutabagaVirtGpuDevice::RutabagaVirtGpuDevice(uint32_t contextId, VirtGpuCapset capset)
- : VirtGpuDevice(capset),
- mContextId(contextId),
- mCapset(capset) {}
+ : VirtGpuDevice(capset), mContextId(contextId), mCapset(capset) {}
RutabagaVirtGpuDevice::~RutabagaVirtGpuDevice() {
EmulatedVirtioGpu::Get().DestroyContext(mContextId);
+ EmulatedVirtioGpu::Reset();
}
int64_t RutabagaVirtGpuDevice::getDeviceHandle() { return -1; }
-VirtGpuCaps RutabagaVirtGpuDevice::getCaps() {
- return EmulatedVirtioGpu::Get().GetCaps(mCapset);
-}
+VirtGpuCaps RutabagaVirtGpuDevice::getCaps() { return EmulatedVirtioGpu::Get().GetCaps(mCapset); }
VirtGpuBlobPtr RutabagaVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
const auto resourceIdOpt = EmulatedVirtioGpu::Get().CreateBlob(mContextId, blobCreate);
@@ -43,36 +39,20 @@
return nullptr;
}
- return VirtGpuBlobPtr(
- new RutabagaVirtGpuResource(*resourceIdOpt,
- RutabagaVirtGpuResource::ResourceType::kBlob,
- mContextId));
+ return VirtGpuBlobPtr(new RutabagaVirtGpuResource(
+ *resourceIdOpt, RutabagaVirtGpuResource::ResourceType::kBlob, mContextId));
}
-VirtGpuBlobPtr RutabagaVirtGpuDevice::createPipeBlob(uint32_t size) {
- const auto resourceIdOpt = EmulatedVirtioGpu::Get().CreatePipeBlob(mContextId, size);
+VirtGpuBlobPtr RutabagaVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height,
+ uint32_t virglFormat) {
+ const auto resourceIdOpt =
+ EmulatedVirtioGpu::Get().CreateVirglBlob(mContextId, width, height, virglFormat);
if (!resourceIdOpt) {
return nullptr;
}
- return VirtGpuBlobPtr(
- new RutabagaVirtGpuResource(*resourceIdOpt,
- RutabagaVirtGpuResource::ResourceType::kPipe,
- mContextId));
-}
-
-VirtGpuBlobPtr RutabagaVirtGpuDevice::createPipeTexture2D(uint32_t width,
- uint32_t height,
- uint32_t format) {
- const auto resourceIdOpt = EmulatedVirtioGpu::Get().CreatePipeTexture2D(mContextId, width, height, format);
- if (!resourceIdOpt) {
- return nullptr;
- }
-
- return VirtGpuBlobPtr(
- new RutabagaVirtGpuResource(*resourceIdOpt,
- RutabagaVirtGpuResource::ResourceType::kPipe,
- mContextId));
+ return VirtGpuBlobPtr(new RutabagaVirtGpuResource(
+ *resourceIdOpt, RutabagaVirtGpuResource::ResourceType::kPipe, mContextId));
}
int RutabagaVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob) {
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuSyncHelper.cpp b/guest/platform/rutabaga/RutabagaVirtGpuSyncHelper.cpp
index 3654389..30b5f3d 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuSyncHelper.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuSyncHelper.cpp
@@ -31,12 +31,8 @@
return syncFd;
}
-int RutabagaVirtGpuSyncHelper::close(int) {
- return 0;
-}
+int RutabagaVirtGpuSyncHelper::close(int) { return 0; }
-SyncHelper* createPlatformSyncHelper() {
- return new RutabagaVirtGpuSyncHelper();
-}
+SyncHelper* createPlatformSyncHelper() { return new RutabagaVirtGpuSyncHelper(); }
} // namespace gfxstream
\ No newline at end of file
diff --git a/guest/platform/stub/StubVirtGpu.h b/guest/platform/stub/StubVirtGpu.h
index 8e3e8fb..35773ec 100644
--- a/guest/platform/stub/StubVirtGpu.h
+++ b/guest/platform/stub/StubVirtGpu.h
@@ -66,14 +66,16 @@
struct VirtGpuCaps getCaps(void) override;
VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createPipeBlob(uint32_t size) override;
- VirtGpuBlobPtr createPipeTexture2D(uint32_t width, uint32_t height, uint32_t format) override;
+ VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat);
VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) override;
int execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob) override;
+ virtual VirtGpuBlobPtr createColorBuffer(int width, int height, uint32_t glFormat);
+ virtual VirtGpuBlobPtr createColorBuffer(int size);
+
private:
int64_t mDeviceHandle;
struct VirtGpuCaps mCaps;
-};
\ No newline at end of file
+};
diff --git a/guest/platform/stub/StubVirtGpuDevice.cpp b/guest/platform/stub/StubVirtGpuDevice.cpp
index 5675a52..c3a6c70 100644
--- a/guest/platform/stub/StubVirtGpuDevice.cpp
+++ b/guest/platform/stub/StubVirtGpuDevice.cpp
@@ -26,7 +26,10 @@
return mDeviceHandle;
}
-VirtGpuBlobPtr StubVirtGpuDevice::createPipeBlob(uint32_t) {
+VirtGpuBlobPtr StubVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) {
+ (void)width;
+ (void)height;
+ (void)virglFormat;
return nullptr;
}
@@ -34,10 +37,6 @@
return nullptr;
}
-VirtGpuBlobPtr StubVirtGpuDevice::createPipeTexture2D(uint32_t, uint32_t, uint32_t) {
- return nullptr;
-}
-
VirtGpuBlobPtr StubVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle&) {
return nullptr;
}
@@ -46,10 +45,18 @@
return -1;
}
+VirtGpuBlobPtr createColorBuffer(int, int, uint32_t) {
+ return nullptr;
+}
+
+VirtGpuBlobPtr createColorBuffer(int) {
+ return nullptr;
+}
+
StubVirtGpuDevice::~StubVirtGpuDevice() {
// Unimplemented stub
}
VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int) {
return new StubVirtGpuDevice(capset);
-}
\ No newline at end of file
+}
diff --git a/guest/vulkan/Android.bp b/guest/vulkan/Android.bp
index 3904f09..4db968f 100644
--- a/guest/vulkan/Android.bp
+++ b/guest/vulkan/Android.bp
@@ -25,15 +25,43 @@
vendor: true,
defaults: [
"libgfxstream_guest_cc_defaults",
+ "mesa_common_defaults_gfxstream",
+ ],
+ generated_headers: [
+ "vk_cmd_queue_header",
+ "vk_physical_device_features_header",
+ "vk_physical_device_properties_header",
],
header_libs: [
"gfxstream_vulkan_headers",
+ "mesa_common_headers_gfxstream",
+ "libnativewindow_headers",
+ "vulkan_enc_headers",
+ ],
+ static_libs: [
+ "libmesa_util_c11_gfxstream",
+ "libmesa_vulkan_util_gfxstream",
+ "libmesa_vulkan_runtime_gfxstream",
+ "libmesa_vulkan_wsi_gfxstream",
+ "libgfxstream_guest_vulkan_entrypoints",
+ "libmesa_util_gfxstream",
+ "libmesa_util_format_gfxstream",
+ "libGoldfishAddressSpace",
+ "libgfxstream_guest_gralloc",
+ "libringbuffer",
+ "libqemupipe.ranchu",
+ "libarect",
+ "libandroidemu_static",
],
shared_libs: [
- "libandroidemu",
"liblog",
+ "libcutils",
+ "libGLESv1_enc",
+ "libGLESv2_enc",
"lib_renderControl_enc",
"libOpenglCodecCommon",
+ "libbase",
+ "libdrm",
],
cflags: [
"-DLOG_TAG=\"goldfish_vulkan\"",
@@ -46,11 +74,21 @@
"-Wno-unused-parameter",
"-Wno-cast-calling-convention",
],
+ ldflags: [
+ // Mesa always adds Bsymbolic when available (see 'ld_args_bsymbolic' in Meson build). Duplicate that
+ // behavior here. '--gc-sections' has stronger justification: this lets drivers drop
+ // shared code unused by that specific driver (particularly relevant for Vulkan drivers).
+ "-Wl,-Bsymbolic",
+ "-Wl,--gc-sections",
+ ],
include_dirs: [
"hardware/google/gfxstream/guest/GoldfishAddressSpace/include",
],
srcs: [
- "goldfish_vulkan.cpp",
+ "gfxstream_vk_device.cpp",
+ "gfxstream_vk_cmd.cpp",
+ "gfxstream_vk_wsi.cpp",
+ ":vulkan_enc_impl",
],
target: {
android: {
@@ -58,6 +96,13 @@
header_libs: [
"hwvulkan_headers",
],
+ shared_libs: [
+ "libnativewindow",
+ "libsync",
+ ],
+ srcs: [
+ "gfxstream_vk_android.cpp",
+ ],
},
},
}
@@ -67,9 +112,9 @@
defaults: [
"libgfxstream_guest_vulkan_defaults",
],
- shared_libs: [
- "libOpenglSystemCommon",
- "libvulkan_enc",
+ static_libs: [
+ "libplatform",
+ "libgfxstream_guest_system_common",
],
}
@@ -79,8 +124,14 @@
"libgfxstream_guest_vulkan_defaults",
],
shared_libs: [
- "libOpenglSystemCommonWithHost",
- "libgfxstream_guest_vulkan_encoder_with_host",
+ "libplatform_rutabaga",
+ "libgfxstream_backend",
+ ],
+ static_libs: [
+ "libgfxstream_guest_system_common_with_host",
+ ],
+ cflags: [
+ "-DEND2END_TESTS",
],
target: {
host: {
diff --git a/guest/vulkan/gfxstream_vk_android.cpp b/guest/vulkan/gfxstream_vk_android.cpp
new file mode 100644
index 0000000..9b07c2b
--- /dev/null
+++ b/guest/vulkan/gfxstream_vk_android.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <errno.h>
+#include <hardware/hardware.h>
+#include <hardware/hwvulkan.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vulkan/vk_icd.h>
+
+#include "gfxstream_vk_entrypoints.h"
+#include "util/macros.h"
+
+static int gfxstream_vk_hal_open(const struct hw_module_t* mod, const char* id,
+ struct hw_device_t** dev);
+static int gfxstream_vk_hal_close(struct hw_device_t* dev);
+
+static_assert(HWVULKAN_DISPATCH_MAGIC == ICD_LOADER_MAGIC, "");
+
+hw_module_methods_t gfxstream_vk_hal_ops = {
+ .open = gfxstream_vk_hal_open,
+};
+
+PUBLIC struct hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+ .common =
+ {
+ .tag = HARDWARE_MODULE_TAG,
+ .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
+ .hal_api_version = HARDWARE_MAKE_API_VERSION(1, 0),
+ .id = HWVULKAN_HARDWARE_MODULE_ID,
+ .name = "gfxstream Vulkan HAL",
+ .author = "Android Open Source Project",
+ .methods = &(gfxstream_vk_hal_ops),
+ },
+};
+
+static int gfxstream_vk_hal_open(const struct hw_module_t* mod, const char* id,
+ struct hw_device_t** dev) {
+ assert(mod == &HAL_MODULE_INFO_SYM.common);
+ assert(strcmp(id, HWVULKAN_DEVICE_0) == 0);
+
+ hwvulkan_device_t* hal_dev = (hwvulkan_device_t*)calloc(1, sizeof(*hal_dev));
+ if (!hal_dev) return -1;
+
+ *hal_dev = (hwvulkan_device_t){
+ .common =
+ {
+ .tag = HARDWARE_DEVICE_TAG,
+ .version = HWVULKAN_DEVICE_API_VERSION_0_1,
+ .module = &HAL_MODULE_INFO_SYM.common,
+ .close = gfxstream_vk_hal_close,
+ },
+ .EnumerateInstanceExtensionProperties = gfxstream_vk_EnumerateInstanceExtensionProperties,
+ .CreateInstance = gfxstream_vk_CreateInstance,
+ .GetInstanceProcAddr = gfxstream_vk_GetInstanceProcAddr,
+ };
+
+ *dev = &hal_dev->common;
+ return 0;
+}
+
+static int gfxstream_vk_hal_close(struct hw_device_t* dev) {
+ /* hwvulkan.h claims that hw_device_t::close() is never called. */
+ return -1;
+}
diff --git a/guest/vulkan/gfxstream_vk_cmd.cpp b/guest/vulkan/gfxstream_vk_cmd.cpp
new file mode 100644
index 0000000..b3d6fce
--- /dev/null
+++ b/guest/vulkan/gfxstream_vk_cmd.cpp
@@ -0,0 +1,188 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ResourceTracker.h"
+#include "VkEncoder.h"
+#include "gfxstream_vk_private.h"
+
+VkResult gfxstream_vk_CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool) {
+ AEMU_SCOPED_TRACE("vkCreateCommandPool");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VkResult result = (VkResult)0;
+ struct gfxstream_vk_command_pool* gfxstream_pCommandPool =
+ (gfxstream_vk_command_pool*)vk_zalloc2(&gfxstream_device->vk.alloc, pAllocator,
+ sizeof(gfxstream_vk_command_pool), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ result = gfxstream_pCommandPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == result) {
+ result = vk_command_pool_init(&gfxstream_device->vk, &gfxstream_pCommandPool->vk,
+ pCreateInfo, pAllocator);
+ }
+ if (VK_SUCCESS == result) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ result = vkEnc->vkCreateCommandPool(gfxstream_device->internal_object, pCreateInfo,
+ pAllocator, &gfxstream_pCommandPool->internal_object,
+ true /* do lock */);
+ }
+ *pCommandPool = gfxstream_vk_command_pool_to_handle(gfxstream_pCommandPool);
+ return result;
+}
+
+void gfxstream_vk_DestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator) {
+ AEMU_SCOPED_TRACE("vkDestroyCommandPool");
+ if (VK_NULL_HANDLE == commandPool) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyCommandPool(gfxstream_device->internal_object,
+ gfxstream_commandPool->internal_object, pAllocator,
+ true /* do lock */);
+ }
+ vk_command_pool_finish(&gfxstream_commandPool->vk);
+ vk_free(&gfxstream_commandPool->vk.alloc, gfxstream_commandPool);
+}
+
+VkResult gfxstream_vk_ResetCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags) {
+ AEMU_SCOPED_TRACE("vkResetCommandPool");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+ VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(
+ gfxstream_device->internal_object, gfxstream_commandPool->internal_object, flags,
+ true /* do lock */);
+ if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
+ gfxstream::vk::ResourceTracker::get()->resetCommandPoolStagingInfo(
+ gfxstream_commandPool->internal_object);
+ }
+ }
+ return vkResetCommandPool_VkResult_return;
+}
+
+static VkResult vk_command_buffer_createOp(struct vk_command_pool*, struct vk_command_buffer**);
+static void vk_command_buffer_resetOp(struct vk_command_buffer*, VkCommandBufferResetFlags);
+static void vk_command_buffer_destroyOp(struct vk_command_buffer*);
+
+static vk_command_buffer_ops gfxstream_vk_commandBufferOps = {
+ .create = vk_command_buffer_createOp,
+ .reset = vk_command_buffer_resetOp,
+ .destroy = vk_command_buffer_destroyOp};
+
+VkResult vk_command_buffer_createOp(struct vk_command_pool* commandPool,
+ struct vk_command_buffer** pCommandBuffer) {
+ VkResult result = VK_SUCCESS;
+ struct gfxstream_vk_command_buffer* gfxstream_commandBuffer =
+ (struct gfxstream_vk_command_buffer*)vk_zalloc(&commandPool->alloc,
+ sizeof(struct gfxstream_vk_command_buffer),
+ 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ if (gfxstream_commandBuffer) {
+ result =
+ vk_command_buffer_init(commandPool, &gfxstream_commandBuffer->vk,
+ &gfxstream_vk_commandBufferOps, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ if (VK_SUCCESS == result) {
+ *pCommandBuffer = &gfxstream_commandBuffer->vk;
+ }
+ } else {
+ result = VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+ return result;
+}
+
+void vk_command_buffer_resetOp(struct vk_command_buffer* commandBuffer,
+ VkCommandBufferResetFlags flags) {
+ (void)flags;
+ vk_command_buffer_reset(commandBuffer);
+}
+
+void vk_command_buffer_destroyOp(struct vk_command_buffer* commandBuffer) {
+ vk_command_buffer_finish(commandBuffer);
+ vk_free(&commandBuffer->pool->alloc, commandBuffer);
+}
+
+VkResult gfxstream_vk_AllocateCommandBuffers(VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers) {
+ AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, pAllocateInfo->commandPool);
+ VkResult result = (VkResult)0;
+ std::vector<gfxstream_vk_command_buffer*> gfxstream_commandBuffers(
+ pAllocateInfo->commandBufferCount);
+ for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
+ result = vk_command_buffer_createOp(&gfxstream_commandPool->vk,
+ (vk_command_buffer**)&gfxstream_commandBuffers[i]);
+ if (VK_SUCCESS == result) {
+ gfxstream_commandBuffers[i]->vk.level = pAllocateInfo->level;
+ } else {
+ break;
+ }
+ }
+ if (VK_SUCCESS == result) {
+ // Create gfxstream-internal commandBuffer array
+ std::vector<VkCommandBuffer> internal_objects(pAllocateInfo->commandBufferCount);
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ VkCommandBufferAllocateInfo internal_allocateInfo;
+ internal_allocateInfo = *pAllocateInfo;
+ internal_allocateInfo.commandPool = gfxstream_commandPool->internal_object;
+ result = resources->on_vkAllocateCommandBuffers(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, &internal_allocateInfo,
+ internal_objects.data());
+ if (result == VK_SUCCESS) {
+ gfxstream::vk::ResourceTracker::get()->addToCommandPool(
+ gfxstream_commandPool->internal_object, pAllocateInfo->commandBufferCount,
+ internal_objects.data());
+ for (uint32_t i = 0; i < (uint32_t)internal_objects.size(); i++) {
+ gfxstream_commandBuffers[i]->internal_object = internal_objects[i];
+ // TODO: Also vk_command_buffer_init() on every mesa command buffer?
+ pCommandBuffers[i] =
+ gfxstream_vk_command_buffer_to_handle(gfxstream_commandBuffers[i]);
+ }
+ }
+ }
+ return result;
+}
+
+void gfxstream_vk_FreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers) {
+ AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+ {
+ // Set up internal commandBuffer array for gfxstream-internal call
+ std::vector<VkCommandBuffer> internal_objects(commandBufferCount);
+ for (uint32_t i = 0; i < commandBufferCount; i++) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+ pCommandBuffers[i]);
+ internal_objects[i] = gfxstream_commandBuffer->internal_object;
+ }
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkFreeCommandBuffers(gfxstream_device->internal_object,
+ gfxstream_commandPool->internal_object, commandBufferCount,
+ internal_objects.data(), true /* do lock */);
+ }
+ for (uint32_t i = 0; i < commandBufferCount; i++) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, pCommandBuffers[i]);
+ vk_command_buffer_destroyOp(&gfxstream_commandBuffer->vk);
+ }
+}
diff --git a/guest/vulkan/gfxstream_vk_device.cpp b/guest/vulkan/gfxstream_vk_device.cpp
new file mode 100644
index 0000000..17a85c3
--- /dev/null
+++ b/guest/vulkan/gfxstream_vk_device.cpp
@@ -0,0 +1,840 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <errno.h>
+#include <string.h>
+
+#include "../vulkan_enc/vk_util.h"
+#include "HostConnection.h"
+#include "ProcessPipe.h"
+#include "ResourceTracker.h"
+#include "VkEncoder.h"
+#include "gfxstream_vk_entrypoints.h"
+#include "gfxstream_vk_private.h"
+#include "vk_alloc.h"
+#include "vk_device.h"
+#include "vk_instance.h"
+#include "vk_sync_dummy.h"
+
+static HostConnection* getConnection(void) {
+ auto hostCon = HostConnection::get();
+ return hostCon;
+}
+
+static gfxstream::vk::VkEncoder* getVkEncoder(HostConnection* con) { return con->vkEncoder(); }
+
+gfxstream::vk::ResourceTracker::ThreadingCallbacks threadingCallbacks = {
+ .hostConnectionGetFunc = getConnection,
+ .vkEncoderGetFunc = getVkEncoder,
+};
+
+VkResult SetupInstance(void) {
+ uint32_t noRenderControlEnc = 0;
+ HostConnection* hostCon = HostConnection::getOrCreate(kCapsetGfxStreamVulkan);
+ if (!hostCon) {
+ ALOGE("vulkan: Failed to get host connection\n");
+ return VK_ERROR_DEVICE_LOST;
+ }
+
+ gfxstream::vk::ResourceTracker::get()->setupCaps(noRenderControlEnc);
+ // Legacy goldfish path: could be deleted once goldfish not used guest-side.
+ if (!noRenderControlEnc) {
+ // Implicitly sets up sequence number
+ ExtendedRCEncoderContext* rcEnc = hostCon->rcEncoder();
+ if (!rcEnc) {
+ ALOGE("vulkan: Failed to get renderControl encoder context\n");
+ return VK_ERROR_DEVICE_LOST;
+ }
+
+ gfxstream::vk::ResourceTracker::get()->setupFeatures(rcEnc->featureInfo_const());
+ }
+
+ gfxstream::vk::ResourceTracker::get()->setThreadingCallbacks(threadingCallbacks);
+ gfxstream::vk::ResourceTracker::get()->setSeqnoPtr(getSeqnoPtrForProcess());
+ gfxstream::vk::VkEncoder* vkEnc = hostCon->vkEncoder();
+ if (!vkEnc) {
+ ALOGE("vulkan: Failed to get Vulkan encoder\n");
+ return VK_ERROR_DEVICE_LOST;
+ }
+
+ return VK_SUCCESS;
+}
+
+#define VK_HOST_CONNECTION(ret) \
+ HostConnection* hostCon = HostConnection::getOrCreate(kCapsetGfxStreamVulkan); \
+ gfxstream::vk::VkEncoder* vkEnc = hostCon->vkEncoder(); \
+ if (!vkEnc) { \
+ ALOGE("vulkan: Failed to get Vulkan encoder\n"); \
+ return ret; \
+ }
+
+static bool instance_extension_table_initialized = false;
+static struct vk_instance_extension_table gfxstream_vk_instance_extensions_supported = {0};
+
+// Provided by Mesa components only; never encoded/decoded through gfxstream
+static const char* const kMesaOnlyInstanceExtension[] = {
+ VK_KHR_SURFACE_EXTENSION_NAME,
+#if defined(LINUX_GUEST_BUILD)
+ VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
+#endif
+ VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
+};
+
+static const char* const kMesaOnlyDeviceExtensions[] = {
+ VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+};
+
+static bool isMesaOnlyInstanceExtension(const char* name) {
+ for (auto mesaExt : kMesaOnlyInstanceExtension) {
+ if (!strncmp(mesaExt, name, VK_MAX_EXTENSION_NAME_SIZE)) return true;
+ }
+ return false;
+}
+
+static bool isMesaOnlyDeviceExtension(const char* name) {
+ for (auto mesaExt : kMesaOnlyDeviceExtensions) {
+ if (!strncmp(mesaExt, name, VK_MAX_EXTENSION_NAME_SIZE)) return true;
+ }
+ return false;
+}
+
+// Filtered extension names for encoding
+static std::vector<const char*> filteredInstanceExtensionNames(uint32_t count,
+ const char* const* extNames) {
+ std::vector<const char*> retList;
+ for (uint32_t i = 0; i < count; ++i) {
+ auto extName = extNames[i];
+ if (!isMesaOnlyInstanceExtension(extName)) {
+ retList.push_back(extName);
+ }
+ }
+ return retList;
+}
+
+static std::vector<const char*> filteredDeviceExtensionNames(uint32_t count,
+ const char* const* extNames) {
+ std::vector<const char*> retList;
+ for (uint32_t i = 0; i < count; ++i) {
+ auto extName = extNames[i];
+ if (!isMesaOnlyDeviceExtension(extName)) {
+ retList.push_back(extName);
+ }
+ }
+ return retList;
+}
+
+static void get_device_extensions(VkPhysicalDevice physDevInternal,
+ struct vk_device_extension_table* deviceExts) {
+ VkResult result = (VkResult)0;
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ uint32_t numDeviceExts = 0;
+ result = resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physDevInternal,
+ NULL, &numDeviceExts, NULL);
+ if (VK_SUCCESS == result) {
+ std::vector<VkExtensionProperties> extProps(numDeviceExts);
+ result = resources->on_vkEnumerateDeviceExtensionProperties(
+ vkEnc, VK_SUCCESS, physDevInternal, NULL, &numDeviceExts, extProps.data());
+ if (VK_SUCCESS == result) {
+ // device extensions from gfxstream
+ for (uint32_t i = 0; i < numDeviceExts; i++) {
+ for (uint32_t j = 0; j < VK_DEVICE_EXTENSION_COUNT; j++) {
+ if (0 == strncmp(extProps[i].extensionName,
+ vk_device_extensions[j].extensionName,
+ VK_MAX_EXTENSION_NAME_SIZE)) {
+ deviceExts->extensions[j] = true;
+ break;
+ }
+ }
+ }
+ // device extensions from Mesa
+ for (uint32_t j = 0; j < VK_DEVICE_EXTENSION_COUNT; j++) {
+ if (isMesaOnlyDeviceExtension(vk_device_extensions[j].extensionName)) {
+ deviceExts->extensions[j] = true;
+ break;
+ }
+ }
+ }
+ }
+}
+
+static VkResult gfxstream_vk_physical_device_init(
+ struct gfxstream_vk_physical_device* physical_device, struct gfxstream_vk_instance* instance,
+ VkPhysicalDevice internal_object) {
+ struct vk_device_extension_table supported_extensions = {0};
+ get_device_extensions(internal_object, &supported_extensions);
+
+ struct vk_physical_device_dispatch_table dispatch_table;
+ memset(&dispatch_table, 0, sizeof(struct vk_physical_device_dispatch_table));
+ vk_physical_device_dispatch_table_from_entrypoints(
+ &dispatch_table, &gfxstream_vk_physical_device_entrypoints, false);
+ vk_physical_device_dispatch_table_from_entrypoints(&dispatch_table,
+ &wsi_physical_device_entrypoints, false);
+
+ // Initialize the mesa object
+ VkResult result = vk_physical_device_init(&physical_device->vk, &instance->vk,
+ &supported_extensions, NULL, NULL, &dispatch_table);
+
+ if (VK_SUCCESS == result) {
+ // Set the gfxstream-internal object
+ physical_device->internal_object = internal_object;
+ physical_device->instance = instance;
+ // Note: Must use dummy_sync for correct sync object path in WSI operations
+ physical_device->sync_types[0] = &vk_sync_dummy_type;
+ physical_device->sync_types[1] = NULL;
+ physical_device->vk.supported_sync_types = physical_device->sync_types;
+
+ result = gfxstream_vk_wsi_init(physical_device);
+ }
+
+ return result;
+}
+
+static void gfxstream_vk_physical_device_finish(
+ struct gfxstream_vk_physical_device* physical_device) {
+ gfxstream_vk_wsi_finish(physical_device);
+
+ vk_physical_device_finish(&physical_device->vk);
+}
+
+static void gfxstream_vk_destroy_physical_device(struct vk_physical_device* physical_device) {
+ gfxstream_vk_physical_device_finish((struct gfxstream_vk_physical_device*)physical_device);
+ vk_free(&physical_device->instance->alloc, physical_device);
+}
+
+static VkResult gfxstream_vk_enumerate_devices(struct vk_instance* vk_instance) {
+ VkResult result = VK_SUCCESS;
+ gfxstream_vk_instance* gfxstream_instance = (gfxstream_vk_instance*)vk_instance;
+ uint32_t deviceCount = 0;
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ result = resources->on_vkEnumeratePhysicalDevices(
+ vkEnc, VK_SUCCESS, gfxstream_instance->internal_object, &deviceCount, NULL);
+ if (VK_SUCCESS != result) return result;
+ std::vector<VkPhysicalDevice> internal_list(deviceCount);
+ result = resources->on_vkEnumeratePhysicalDevices(
+ vkEnc, VK_SUCCESS, gfxstream_instance->internal_object, &deviceCount, internal_list.data());
+
+ if (VK_SUCCESS == result) {
+ for (uint32_t i = 0; i < deviceCount; i++) {
+ struct gfxstream_vk_physical_device* gfxstream_physicalDevice =
+ (struct gfxstream_vk_physical_device*)vk_zalloc(
+ &gfxstream_instance->vk.alloc, sizeof(struct gfxstream_vk_physical_device), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (!gfxstream_physicalDevice) {
+ result = VK_ERROR_OUT_OF_HOST_MEMORY;
+ break;
+ }
+ result = gfxstream_vk_physical_device_init(gfxstream_physicalDevice, gfxstream_instance,
+ internal_list[i]);
+ if (VK_SUCCESS == result) {
+ list_addtail(&gfxstream_physicalDevice->vk.link,
+ &gfxstream_instance->vk.physical_devices.list);
+ } else {
+ vk_free(&gfxstream_instance->vk.alloc, gfxstream_physicalDevice);
+ break;
+ }
+ }
+ }
+
+ return result;
+}
+
+static struct vk_instance_extension_table* get_instance_extensions() {
+ struct vk_instance_extension_table* const retTablePtr =
+ &gfxstream_vk_instance_extensions_supported;
+ if (!instance_extension_table_initialized) {
+ VkResult result = SetupInstance();
+ if (VK_SUCCESS == result) {
+ VK_HOST_CONNECTION(retTablePtr)
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ uint32_t numInstanceExts = 0;
+ result = resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, NULL,
+ &numInstanceExts, NULL);
+ if (VK_SUCCESS == result) {
+ std::vector<VkExtensionProperties> extProps(numInstanceExts);
+ result = resources->on_vkEnumerateInstanceExtensionProperties(
+ vkEnc, VK_SUCCESS, NULL, &numInstanceExts, extProps.data());
+ if (VK_SUCCESS == result) {
+ // instance extensions from gfxstream
+ for (uint32_t i = 0; i < numInstanceExts; i++) {
+ for (uint32_t j = 0; j < VK_INSTANCE_EXTENSION_COUNT; j++) {
+ if (0 == strncmp(extProps[i].extensionName,
+ vk_instance_extensions[j].extensionName,
+ VK_MAX_EXTENSION_NAME_SIZE)) {
+ gfxstream_vk_instance_extensions_supported.extensions[j] = true;
+ break;
+ }
+ }
+ }
+ // instance extensions from Mesa
+ for (uint32_t j = 0; j < VK_INSTANCE_EXTENSION_COUNT; j++) {
+ if (isMesaOnlyInstanceExtension(vk_instance_extensions[j].extensionName)) {
+ gfxstream_vk_instance_extensions_supported.extensions[j] = true;
+ }
+ }
+ instance_extension_table_initialized = true;
+ }
+ }
+ }
+ }
+ return retTablePtr;
+}
+
+VkResult gfxstream_vk_CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance) {
+ AEMU_SCOPED_TRACE("vkCreateInstance");
+
+ struct gfxstream_vk_instance* instance;
+
+ pAllocator = pAllocator ?: vk_default_allocator();
+ instance = (struct gfxstream_vk_instance*)vk_zalloc(pAllocator, sizeof(*instance), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ if (NULL == instance) {
+ return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
+ }
+
+ VkResult result = VK_SUCCESS;
+ /* Encoder call */
+ {
+ ALOGE("calling setup instance internally");
+ result = SetupInstance();
+ if (VK_SUCCESS != result) {
+ return vk_error(NULL, result);
+ }
+ uint32_t initialEnabledExtensionCount = pCreateInfo->enabledExtensionCount;
+ const char* const* initialPpEnabledExtensionNames = pCreateInfo->ppEnabledExtensionNames;
+ std::vector<const char*> filteredExts = filteredInstanceExtensionNames(
+ pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames);
+ // Temporarily modify createInfo for the encoder call
+ VkInstanceCreateInfo* mutableCreateInfo = (VkInstanceCreateInfo*)pCreateInfo;
+ mutableCreateInfo->enabledExtensionCount = static_cast<uint32_t>(filteredExts.size());
+ mutableCreateInfo->ppEnabledExtensionNames = filteredExts.data();
+
+ VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST);
+ result = vkEnc->vkCreateInstance(pCreateInfo, nullptr, &instance->internal_object,
+ true /* do lock */);
+ if (VK_SUCCESS != result) {
+ return vk_error(NULL, result);
+ }
+ // Revert the createInfo the user-set data
+ mutableCreateInfo->enabledExtensionCount = initialEnabledExtensionCount;
+ mutableCreateInfo->ppEnabledExtensionNames = initialPpEnabledExtensionNames;
+ }
+
+ struct vk_instance_dispatch_table dispatch_table;
+ memset(&dispatch_table, 0, sizeof(struct vk_instance_dispatch_table));
+ vk_instance_dispatch_table_from_entrypoints(&dispatch_table, &gfxstream_vk_instance_entrypoints,
+ false);
+ vk_instance_dispatch_table_from_entrypoints(&dispatch_table, &wsi_instance_entrypoints, false);
+
+ result = vk_instance_init(&instance->vk, get_instance_extensions(), &dispatch_table,
+ pCreateInfo, pAllocator);
+
+ if (result != VK_SUCCESS) {
+ vk_free(pAllocator, instance);
+ return vk_error(NULL, result);
+ }
+
+ instance->vk.physical_devices.enumerate = gfxstream_vk_enumerate_devices;
+ instance->vk.physical_devices.destroy = gfxstream_vk_destroy_physical_device;
+ // TODO: instance->vk.physical_devices.try_create_for_drm (?)
+
+ *pInstance = gfxstream_vk_instance_to_handle(instance);
+ return VK_SUCCESS;
+}
+
+void gfxstream_vk_DestroyInstance(VkInstance _instance, const VkAllocationCallbacks* pAllocator) {
+ AEMU_SCOPED_TRACE("vkDestroyInstance");
+ if (VK_NULL_HANDLE == _instance) return;
+
+ VK_FROM_HANDLE(gfxstream_vk_instance, instance, _instance);
+
+ VK_HOST_CONNECTION()
+ vkEnc->vkDestroyInstance(instance->internal_object, pAllocator, true /* do lock */);
+
+ vk_instance_finish(&instance->vk);
+ vk_free(&instance->vk.alloc, instance);
+
+ // To make End2EndTests happy, since now the host connection is statically linked to
+ // libvulkan_ranchu.so [separate HostConnections now].
+#if defined(END2END_TESTS)
+ hostCon->exit();
+ processPipeRestart();
+#endif
+}
+
+VkResult gfxstream_vk_EnumerateInstanceExtensionProperties(const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties) {
+ AEMU_SCOPED_TRACE("vkvkEnumerateInstanceExtensionProperties");
+ (void)pLayerName;
+
+ return vk_enumerate_instance_extension_properties(get_instance_extensions(), pPropertyCount,
+ pProperties);
+}
+
+VkResult gfxstream_vk_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties) {
+ AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
+ (void)pLayerName;
+ VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+
+ VK_OUTARRAY_MAKE_TYPED(VkExtensionProperties, out, pProperties, pPropertyCount);
+
+ for (int i = 0; i < VK_DEVICE_EXTENSION_COUNT; i++) {
+ if (!pdevice->supported_extensions.extensions[i]) continue;
+
+ vk_outarray_append_typed(VkExtensionProperties, &out, prop) {
+ *prop = vk_device_extensions[i];
+ }
+ }
+
+ return vk_outarray_status(&out);
+}
+
+VkResult gfxstream_vk_CreateDevice(VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+ AEMU_SCOPED_TRACE("vkCreateDevice");
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ VkResult result = (VkResult)0;
+
+ /*
+ * Android's libvulkan implements VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, but
+ * passes it to the underlying driver anyways. See:
+ *
+ * https://android-review.googlesource.com/c/platform/hardware/google/gfxstream/+/2839438
+ *
+ * and associated bugs. Mesa VK runtime also checks this, so we have to filter out before
+ * reaches it. vk_find_struct<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT>(..) doesn't
+ * work for some reason.
+ */
+ VkBaseInStructure* extensionCreateInfo = (VkBaseInStructure*)(pCreateInfo->pNext);
+ while (extensionCreateInfo) {
+ if (extensionCreateInfo->sType ==
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT) {
+ auto swapchainMaintenance1Features =
+ reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
+ extensionCreateInfo);
+ swapchainMaintenance1Features->swapchainMaintenance1 = VK_FALSE;
+ }
+ extensionCreateInfo = (VkBaseInStructure*)(extensionCreateInfo->pNext);
+ }
+
+ const VkAllocationCallbacks* pMesaAllocator =
+ pAllocator ?: &gfxstream_physicalDevice->instance->vk.alloc;
+ struct gfxstream_vk_device* gfxstream_device = (struct gfxstream_vk_device*)vk_zalloc(
+ pMesaAllocator, sizeof(struct gfxstream_vk_device), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ result = gfxstream_device ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == result) {
+ uint32_t initialEnabledExtensionCount = pCreateInfo->enabledExtensionCount;
+ const char* const* initialPpEnabledExtensionNames = pCreateInfo->ppEnabledExtensionNames;
+ std::vector<const char*> filteredExts = filteredDeviceExtensionNames(
+ pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames);
+ // Temporarily modify createInfo for the encoder call
+ VkDeviceCreateInfo* mutableCreateInfo = (VkDeviceCreateInfo*)pCreateInfo;
+ mutableCreateInfo->enabledExtensionCount = static_cast<uint32_t>(filteredExts.size());
+ mutableCreateInfo->ppEnabledExtensionNames = filteredExts.data();
+
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ result = vkEnc->vkCreateDevice(gfxstream_physicalDevice->internal_object, pCreateInfo,
+ pAllocator, &gfxstream_device->internal_object,
+ true /* do lock */);
+ // Revert the createInfo the user-set data
+ mutableCreateInfo->enabledExtensionCount = initialEnabledExtensionCount;
+ mutableCreateInfo->ppEnabledExtensionNames = initialPpEnabledExtensionNames;
+ }
+ if (VK_SUCCESS == result) {
+ struct vk_device_dispatch_table dispatch_table;
+ memset(&dispatch_table, 0, sizeof(struct vk_device_dispatch_table));
+ vk_device_dispatch_table_from_entrypoints(&dispatch_table, &gfxstream_vk_device_entrypoints,
+ false);
+ vk_device_dispatch_table_from_entrypoints(&dispatch_table, &wsi_device_entrypoints, false);
+
+ result = vk_device_init(&gfxstream_device->vk, &gfxstream_physicalDevice->vk,
+ &dispatch_table, pCreateInfo, pMesaAllocator);
+ }
+ if (VK_SUCCESS == result) {
+ gfxstream_device->physical_device = gfxstream_physicalDevice;
+ // TODO: Initialize cmd_dispatch for emulated secondary command buffer support?
+ gfxstream_device->vk.command_dispatch_table = &gfxstream_device->cmd_dispatch;
+ *pDevice = gfxstream_vk_device_to_handle(gfxstream_device);
+ } else {
+ vk_free(pMesaAllocator, gfxstream_device);
+ }
+
+ return result;
+}
+
+void gfxstream_vk_DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+ AEMU_SCOPED_TRACE("vkDestroyDevice");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ if (VK_NULL_HANDLE == device) return;
+
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyDevice(gfxstream_device->internal_object, pAllocator, true /* do lock */);
+
+ /* Must destroy device queues manually */
+ vk_foreach_queue_safe(queue, &gfxstream_device->vk) {
+ vk_queue_finish(queue);
+ vk_free(&gfxstream_device->vk.alloc, queue);
+ }
+ vk_device_finish(&gfxstream_device->vk);
+ vk_free(&gfxstream_device->vk.alloc, gfxstream_device);
+}
+
+void gfxstream_vk_GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
+ VkQueue* pQueue) {
+ AEMU_SCOPED_TRACE("vkGetDeviceQueue");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_queue* gfxstream_queue = (struct gfxstream_vk_queue*)vk_zalloc(
+ &gfxstream_device->vk.alloc, sizeof(struct gfxstream_vk_queue), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+ VkResult result = gfxstream_queue ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == result) {
+ VkDeviceQueueCreateInfo createInfo = {
+ .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ .pNext = NULL,
+ .flags = 0,
+ .queueFamilyIndex = queueFamilyIndex,
+ .queueCount = 1,
+ .pQueuePriorities = NULL,
+ };
+ result =
+ vk_queue_init(&gfxstream_queue->vk, &gfxstream_device->vk, &createInfo, queueIndex);
+ }
+ if (VK_SUCCESS == result) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceQueue(gfxstream_device->internal_object, queueFamilyIndex, queueIndex,
+ &gfxstream_queue->internal_object, true /* do lock */);
+
+ gfxstream_queue->device = gfxstream_device;
+ *pQueue = gfxstream_vk_queue_to_handle(gfxstream_queue);
+ } else {
+ *pQueue = VK_NULL_HANDLE;
+ }
+}
+
+void gfxstream_vk_GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue) {
+ AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_queue* gfxstream_queue = (struct gfxstream_vk_queue*)vk_zalloc(
+ &gfxstream_device->vk.alloc, sizeof(struct gfxstream_vk_queue), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+ VkResult result = gfxstream_queue ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == result) {
+ VkDeviceQueueCreateInfo createInfo = {
+ .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ .pNext = NULL,
+ .flags = pQueueInfo->flags,
+ .queueFamilyIndex = pQueueInfo->queueFamilyIndex,
+ .queueCount = 1,
+ .pQueuePriorities = NULL,
+ };
+ result = vk_queue_init(&gfxstream_queue->vk, &gfxstream_device->vk, &createInfo,
+ pQueueInfo->queueIndex);
+ }
+ if (VK_SUCCESS == result) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceQueue2(gfxstream_device->internal_object, pQueueInfo,
+ &gfxstream_queue->internal_object, true /* do lock */);
+
+ gfxstream_queue->device = gfxstream_device;
+ *pQueue = gfxstream_vk_queue_to_handle(gfxstream_queue);
+ } else {
+ *pQueue = VK_NULL_HANDLE;
+ }
+}
+
+/* The loader wants us to expose a second GetInstanceProcAddr function
+ * to work around certain LD_PRELOAD issues seen in apps.
+ */
+extern "C" PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName);
+
+extern "C" PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName) {
+ return gfxstream_vk_GetInstanceProcAddr(instance, pName);
+}
+
+/* vk_icd.h does not declare this function, so we declare it here to
+ * suppress Wmissing-prototypes.
+ */
+extern "C" PUBLIC VKAPI_ATTR VkResult VKAPI_CALL
+vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion);
+
+extern "C" PUBLIC VKAPI_ATTR VkResult VKAPI_CALL
+vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) {
+ *pSupportedVersion = std::min(*pSupportedVersion, 3u);
+ return VK_SUCCESS;
+}
+
+/* With version 4+ of the loader interface the ICD should expose
+ * vk_icdGetPhysicalDeviceProcAddr()
+ */
+extern "C" PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+vk_icdGetPhysicalDeviceProcAddr(VkInstance _instance, const char* pName);
+
+PFN_vkVoidFunction vk_icdGetPhysicalDeviceProcAddr(VkInstance _instance, const char* pName) {
+ VK_FROM_HANDLE(gfxstream_vk_instance, instance, _instance);
+
+ return vk_instance_get_physical_device_proc_addr(&instance->vk, pName);
+}
+
+PFN_vkVoidFunction gfxstream_vk_GetInstanceProcAddr(VkInstance _instance, const char* pName) {
+ VK_FROM_HANDLE(gfxstream_vk_instance, instance, _instance);
+ return vk_instance_get_proc_addr(&instance->vk, &gfxstream_vk_instance_entrypoints, pName);
+}
+
+PFN_vkVoidFunction gfxstream_vk_GetDeviceProcAddr(VkDevice _device, const char* pName) {
+ AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
+ VK_FROM_HANDLE(gfxstream_vk_device, device, _device);
+ return vk_device_get_proc_addr(&device->vk, pName);
+}
+
+VkResult gfxstream_vk_AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory) {
+ AEMU_SCOPED_TRACE("vkAllocateMemory");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
+ struct gfxstream_vk_device_memory* gfxstream_pMemory =
+ (struct gfxstream_vk_device_memory*)vk_device_memory_create(
+ (vk_device*)gfxstream_device, pAllocateInfo, pAllocator,
+ sizeof(struct gfxstream_vk_device_memory));
+ /* VkMemoryDedicatedAllocateInfo */
+ VkMemoryDedicatedAllocateInfo* dedicatedAllocInfoPtr =
+ (VkMemoryDedicatedAllocateInfo*)vk_find_struct<VkMemoryDedicatedAllocateInfo>(
+ pAllocateInfo);
+ if (dedicatedAllocInfoPtr) {
+ if (dedicatedAllocInfoPtr->buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, dedicatedAllocInfoPtr->buffer);
+ dedicatedAllocInfoPtr->buffer = gfxstream_buffer->internal_object;
+ }
+ if (dedicatedAllocInfoPtr->image) {
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, dedicatedAllocInfoPtr->image);
+ dedicatedAllocInfoPtr->image = gfxstream_image->internal_object;
+ }
+ }
+ vkAllocateMemory_VkResult_return = gfxstream_pMemory ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkAllocateMemory_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pAllocateInfo, pAllocator,
+ &gfxstream_pMemory->internal_object);
+ }
+ *pMemory = gfxstream_vk_device_memory_to_handle(gfxstream_pMemory);
+ return vkAllocateMemory_VkResult_return;
+}
+
+void gfxstream_vk_CmdBeginRenderPass(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents) {
+ AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ VkRenderPassBeginInfo internal_pRenderPassBegin = vk_make_orphan_copy(*pRenderPassBegin);
+ vk_struct_chain_iterator structChainIter =
+ vk_make_chain_iterator(&internal_pRenderPassBegin);
+ /* VkRenderPassBeginInfo::renderPass */
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pRenderPassBegin.renderPass);
+ internal_pRenderPassBegin.renderPass = gfxstream_renderPass->internal_object;
+ /* VkRenderPassBeginInfo::framebuffer */
+ VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_pRenderPassBegin.framebuffer);
+ internal_pRenderPassBegin.framebuffer = gfxstream_framebuffer->internal_object;
+ /* pNext = VkRenderPassAttachmentBeginInfo */
+ std::vector<VkImageView> internal_pAttachments;
+ VkRenderPassAttachmentBeginInfo internal_renderPassAttachmentBeginInfo;
+ VkRenderPassAttachmentBeginInfo* pRenderPassAttachmentBeginInfo =
+ (VkRenderPassAttachmentBeginInfo*)vk_find_struct<VkRenderPassAttachmentBeginInfo>(
+ pRenderPassBegin);
+ if (pRenderPassAttachmentBeginInfo) {
+ internal_renderPassAttachmentBeginInfo = *pRenderPassAttachmentBeginInfo;
+ /* VkRenderPassAttachmentBeginInfo::pAttachments */
+ internal_pAttachments.reserve(internal_renderPassAttachmentBeginInfo.attachmentCount);
+ for (uint32_t i = 0; i < internal_renderPassAttachmentBeginInfo.attachmentCount; i++) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_image_view,
+ internal_renderPassAttachmentBeginInfo.pAttachments[i]);
+ internal_pAttachments[i] = gfxstream_image_view->internal_object;
+ }
+ internal_renderPassAttachmentBeginInfo.pAttachments = internal_pAttachments.data();
+ vk_append_struct(&structChainIter, &internal_renderPassAttachmentBeginInfo);
+ }
+ vkEnc->vkCmdBeginRenderPass(gfxstream_commandBuffer->internal_object,
+ &internal_pRenderPassBegin, contents, true /* do lock */);
+ }
+}
+
+void gfxstream_vk_CmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo) {
+ AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ VkRenderPassBeginInfo internal_pRenderPassBegin = vk_make_orphan_copy(*pRenderPassBegin);
+ vk_struct_chain_iterator structChainIter =
+ vk_make_chain_iterator(&internal_pRenderPassBegin);
+ /* VkRenderPassBeginInfo::renderPass */
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pRenderPassBegin.renderPass);
+ internal_pRenderPassBegin.renderPass = gfxstream_renderPass->internal_object;
+ /* VkRenderPassBeginInfo::framebuffer */
+ VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_pRenderPassBegin.framebuffer);
+ internal_pRenderPassBegin.framebuffer = gfxstream_framebuffer->internal_object;
+ /* pNext = VkRenderPassAttachmentBeginInfo */
+ std::vector<VkImageView> internal_pAttachments;
+ VkRenderPassAttachmentBeginInfo internal_renderPassAttachmentBeginInfo;
+ VkRenderPassAttachmentBeginInfo* pRenderPassAttachmentBeginInfo =
+ (VkRenderPassAttachmentBeginInfo*)vk_find_struct<VkRenderPassAttachmentBeginInfo>(
+ pRenderPassBegin);
+ if (pRenderPassAttachmentBeginInfo) {
+ internal_renderPassAttachmentBeginInfo = *pRenderPassAttachmentBeginInfo;
+ /* VkRenderPassAttachmentBeginInfo::pAttachments */
+ internal_pAttachments.reserve(internal_renderPassAttachmentBeginInfo.attachmentCount);
+ for (uint32_t i = 0; i < internal_renderPassAttachmentBeginInfo.attachmentCount; i++) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_image_view,
+ internal_renderPassAttachmentBeginInfo.pAttachments[i]);
+ internal_pAttachments[i] = gfxstream_image_view->internal_object;
+ }
+ internal_renderPassAttachmentBeginInfo.pAttachments = internal_pAttachments.data();
+ vk_append_struct(&structChainIter, &internal_renderPassAttachmentBeginInfo);
+ }
+ vkEnc->vkCmdBeginRenderPass2KHR(gfxstream_commandBuffer->internal_object,
+ &internal_pRenderPassBegin, pSubpassBeginInfo,
+ true /* do lock */);
+ }
+}
+
+VkResult gfxstream_vk_GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
+ AEMU_SCOPED_TRACE("vkGetMemoryFdKHR");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkMemoryGetFdInfoKHR> internal_pGetFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pGetFdInfo[i] = pGetFdInfo[i];
+ /* VkMemoryGetFdInfoKHR::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pGetFdInfo[i].memory);
+ internal_pGetFdInfo[i].memory = gfxstream_memory->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetMemoryFdKHR_VkResult_return = resources->on_vkGetMemoryFdKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
+ }
+ return vkGetMemoryFdKHR_VkResult_return;
+}
+
+VkResult gfxstream_vk_EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties) {
+ AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
+ auto result = SetupInstance();
+ if (VK_SUCCESS != result) {
+ return vk_error(NULL, result);
+ }
+
+ VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnumerateInstanceLayerProperties_VkResult_return =
+ vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties,
+ true /* do lock */);
+ }
+ return vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+
+VkResult gfxstream_vk_EnumerateInstanceVersion(uint32_t* pApiVersion) {
+ AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
+ auto result = SetupInstance();
+ if (VK_SUCCESS != result) {
+ return vk_error(NULL, result);
+ }
+
+ VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnumerateInstanceVersion_VkResult_return =
+ vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
+ }
+ return vkEnumerateInstanceVersion_VkResult_return;
+}
+
+VkResult gfxstream_vk_CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
+ AEMU_SCOPED_TRACE("vkCreateComputePipelines");
+ VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+ struct gfxstream_vk_pipeline* gfxstream_pPipelines = (gfxstream_vk_pipeline*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_pipeline), VK_OBJECT_TYPE_PIPELINE);
+ vkCreateComputePipelines_VkResult_return =
+ gfxstream_pPipelines ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateComputePipelines_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkComputePipelineCreateInfo> internal_pCreateInfos(createInfoCount);
+ std::vector<VkPipelineShaderStageCreateInfo> internal_VkComputePipelineCreateInfo_stage(createInfoCount);
+ for (uint32_t i = 0; i < createInfoCount; ++i) {
+ internal_pCreateInfos[i] = pCreateInfos[i];
+ /* VkComputePipelineCreateInfo::stage */
+ {
+ internal_VkComputePipelineCreateInfo_stage[i] = internal_pCreateInfos[i].stage;
+ /* VkPipelineShaderStageCreateInfo::module */
+ if (internal_VkComputePipelineCreateInfo_stage[i].module) {
+ VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_module,
+ internal_VkComputePipelineCreateInfo_stage[i].module);
+ internal_VkComputePipelineCreateInfo_stage[i].module =
+ gfxstream_module->internal_object;
+ }
+ internal_pCreateInfos[i].stage = internal_VkComputePipelineCreateInfo_stage[i];
+ }
+ /* VkComputePipelineCreateInfo::layout */
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout,
+ internal_pCreateInfos[i].layout);
+ internal_pCreateInfos[i].layout = gfxstream_layout->internal_object;
+ /* VkComputePipelineCreateInfo::basePipelineHandle */
+ if (internal_pCreateInfos[i].basePipelineHandle) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_basePipelineHandle,
+ internal_pCreateInfos[i].basePipelineHandle);
+ internal_pCreateInfos[i].basePipelineHandle =
+ gfxstream_basePipelineHandle->internal_object;
+ }
+ }
+ vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(
+ gfxstream_device->internal_object,
+ gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
+ createInfoCount, internal_pCreateInfos.data(), pAllocator,
+ &gfxstream_pPipelines->internal_object, true /* do lock */);
+ }
+ *pPipelines = gfxstream_vk_pipeline_to_handle(gfxstream_pPipelines);
+ return vkCreateComputePipelines_VkResult_return;
+}
diff --git a/guest/vulkan/gfxstream_vk_fuchsia.cpp b/guest/vulkan/gfxstream_vk_fuchsia.cpp
new file mode 100644
index 0000000..bfd220c
--- /dev/null
+++ b/guest/vulkan/gfxstream_vk_fuchsia.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <fidl/fuchsia.logger/cpp/wire.h>
+#include <lib/syslog/global.h>
+#include <lib/zx/channel.h>
+#include <lib/zx/socket.h>
+#include <lib/zxio/zxio.h>
+#include <unistd.h>
+
+#include "TraceProviderFuchsia.h"
+#include "services/service_connector.h"
+
+class VulkanDevice {
+ public:
+ VulkanDevice() : mHostSupportsGoldfish(IsAccessible(QEMU_PIPE_PATH)) {
+ InitLogger();
+ InitTraceProvider();
+ gfxstream::vk::ResourceTracker::get();
+ }
+
+ static void InitLogger();
+
+ static bool IsAccessible(const char* name) {
+ zx_handle_t handle = GetConnectToServiceFunction()(name);
+ if (handle == ZX_HANDLE_INVALID) return false;
+
+ zxio_storage_t io_storage;
+ zx_status_t status = zxio_create(handle, &io_storage);
+ if (status != ZX_OK) return false;
+
+ status = zxio_close(&io_storage.io, /*should_wait=*/true);
+ if (status != ZX_OK) return false;
+
+ return true;
+ }
+
+ static VulkanDevice& GetInstance() {
+ static VulkanDevice g_instance;
+ return g_instance;
+ }
+
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
+ return ::GetInstanceProcAddr(instance, name);
+ }
+
+ private:
+ void InitTraceProvider();
+
+ TraceProviderFuchsia mTraceProvider;
+ const bool mHostSupportsGoldfish;
+};
+
+void VulkanDevice::InitLogger() {
+ auto log_socket = ([]() -> std::optional<zx::socket> {
+ fidl::ClientEnd<fuchsia_logger::LogSink> channel{
+ zx::channel{GetConnectToServiceFunction()("/svc/fuchsia.logger.LogSink")}};
+ if (!channel.is_valid()) return std::nullopt;
+
+ zx::socket local_socket, remote_socket;
+ zx_status_t status = zx::socket::create(ZX_SOCKET_DATAGRAM, &local_socket, &remote_socket);
+ if (status != ZX_OK) return std::nullopt;
+
+ auto result = fidl::WireCall(channel)->Connect(std::move(remote_socket));
+
+ if (!result.ok()) return std::nullopt;
+
+ return local_socket;
+ })();
+ if (!log_socket) return;
+
+ fx_logger_config_t config = {
+ .min_severity = FX_LOG_INFO,
+ .log_sink_socket = log_socket->release(),
+ .tags = nullptr,
+ .num_tags = 0,
+ };
+
+ fx_log_reconfigure(&config);
+}
+
+void VulkanDevice::InitTraceProvider() {
+ if (!mTraceProvider.Initialize()) {
+ ALOGE("Trace provider failed to initialize");
+ }
+}
+
+typedef VkResult(VKAPI_PTR* PFN_vkOpenInNamespaceAddr)(const char* pName, uint32_t handle);
+
+namespace {
+
+PFN_vkOpenInNamespaceAddr g_vulkan_connector;
+
+zx_handle_t LocalConnectToServiceFunction(const char* pName) {
+ zx::channel remote_endpoint, local_endpoint;
+ zx_status_t status;
+ if ((status = zx::channel::create(0, &remote_endpoint, &local_endpoint)) != ZX_OK) {
+ ALOGE("zx::channel::create failed: %d", status);
+ return ZX_HANDLE_INVALID;
+ }
+ if ((status = g_vulkan_connector(pName, remote_endpoint.release())) != ZX_OK) {
+ ALOGE("vulkan_connector failed: %d", status);
+ return ZX_HANDLE_INVALID;
+ }
+ return local_endpoint.release();
+}
+
+} // namespace
+
+extern "C" __attribute__((visibility("default"))) void vk_icdInitializeOpenInNamespaceCallback(
+ PFN_vkOpenInNamespaceAddr callback) {
+ g_vulkan_connector = callback;
+ SetConnectToServiceFunction(&LocalConnectToServiceFunction);
+}
diff --git a/guest/vulkan/gfxstream_vk_wsi.cpp b/guest/vulkan/gfxstream_vk_wsi.cpp
new file mode 100644
index 0000000..be212ac
--- /dev/null
+++ b/guest/vulkan/gfxstream_vk_wsi.cpp
@@ -0,0 +1,47 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gfxstream_vk_entrypoints.h"
+#include "gfxstream_vk_private.h"
+#include "wsi_common.h"
+
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+gfxstream_vk_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char* pName) {
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, pdevice, physicalDevice);
+ return vk_instance_get_proc_addr_unchecked(&pdevice->instance->vk, pName);
+}
+
+VkResult gfxstream_vk_wsi_init(struct gfxstream_vk_physical_device* physical_device) {
+ VkResult result = (VkResult)0;
+
+ const struct wsi_device_options options = {.sw_device = false};
+ result = wsi_device_init(
+ &physical_device->wsi_device, gfxstream_vk_physical_device_to_handle(physical_device),
+ gfxstream_vk_wsi_proc_addr, &physical_device->instance->vk.alloc, -1, NULL, &options);
+ if (result != VK_SUCCESS) return result;
+
+ // Allow guest-side modifier code paths
+ physical_device->wsi_device.supports_modifiers = true;
+ // For DRM, uses the buffer-blit path for WSI images
+ physical_device->wsi_device.supports_scanout = false;
+
+ physical_device->vk.wsi_device = &physical_device->wsi_device;
+
+ return result;
+}
+
+void gfxstream_vk_wsi_finish(struct gfxstream_vk_physical_device* physical_device) {
+ physical_device->vk.wsi_device = NULL;
+ wsi_device_finish(&physical_device->wsi_device, &physical_device->instance->vk.alloc);
+}
diff --git a/guest/vulkan/goldfish_vulkan.cpp b/guest/vulkan/goldfish_vulkan.cpp
deleted file mode 100644
index bd3762e..0000000
--- a/guest/vulkan/goldfish_vulkan.cpp
+++ /dev/null
@@ -1,380 +0,0 @@
-// Copyright (C) 2018 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#if defined(__ANDROID__)
-#include <hardware/hwvulkan.h>
-#endif // defined(__ANDROID__)
-
-#include <log/log.h>
-
-#include <errno.h>
-#include <string.h>
-#ifdef VK_USE_PLATFORM_FUCHSIA
-#include <fidl/fuchsia.logger/cpp/wire.h>
-#include <lib/syslog/global.h>
-#include <lib/zx/channel.h>
-#include <lib/zx/socket.h>
-#include <lib/zxio/zxio.h>
-#include <unistd.h>
-
-#include "TraceProviderFuchsia.h"
-#include "services/service_connector.h"
-#endif
-
-#include "HostConnection.h"
-#include "ProcessPipe.h"
-#include "ResourceTracker.h"
-#include "VkEncoder.h"
-#include "func_table.h"
-
-namespace {
-
-#if defined(__ANDROID__)
-
-int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
-
-hw_module_methods_t goldfish_vulkan_module_methods = {
- .open = OpenDevice
-};
-
-extern "C" __attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
- .common = {
- .tag = HARDWARE_MODULE_TAG,
- .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
- .hal_api_version = HARDWARE_HAL_API_VERSION,
- .id = HWVULKAN_HARDWARE_MODULE_ID,
- .name = "Goldfish Vulkan Driver",
- .author = "The Android Open Source Project",
- .methods = &goldfish_vulkan_module_methods,
- },
-};
-
-int CloseDevice(struct hw_device_t* /*device*/) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::GetInstanceProcAddr");
- // nothing to do - opening a device doesn't allocate any resources
- return 0;
-}
-
-#endif // defined(__ANDROID__)
-
-static HostConnection* getConnection(void) {
- auto hostCon = HostConnection::get();
- return hostCon;
-}
-
-static gfxstream::vk::VkEncoder* getVkEncoder(HostConnection* con) { return con->vkEncoder(); }
-
-gfxstream::vk::ResourceTracker::ThreadingCallbacks threadingCallbacks = {
- .hostConnectionGetFunc = getConnection,
- .vkEncoderGetFunc = getVkEncoder,
-};
-
-VkResult SetupInstance(void) {
- uint32_t noRenderControlEnc = 0;
- HostConnection* hostCon = HostConnection::getOrCreate(kCapsetGfxStreamVulkan);
- if (!hostCon) {
- ALOGE("vulkan: Failed to get host connection\n");
- return VK_ERROR_DEVICE_LOST;
- }
-
- gfxstream::vk::ResourceTracker::get()->setupCaps(noRenderControlEnc);
- // Legacy goldfish path: could be deleted once goldfish not used guest-side.
- if (!noRenderControlEnc) {
- // Implicitly sets up sequence number
- ExtendedRCEncoderContext* rcEnc = hostCon->rcEncoder();
- if (!rcEnc) {
- ALOGE("vulkan: Failed to get renderControl encoder context\n");
- return VK_ERROR_DEVICE_LOST;
- }
-
- gfxstream::vk::ResourceTracker::get()->setupFeatures(rcEnc->featureInfo_const());
- }
-
- gfxstream::vk::ResourceTracker::get()->setThreadingCallbacks(threadingCallbacks);
- gfxstream::vk::ResourceTracker::get()->setSeqnoPtr(getSeqnoPtrForProcess());
- gfxstream::vk::VkEncoder* vkEnc = hostCon->vkEncoder();
- if (!vkEnc) {
- ALOGE("vulkan: Failed to get Vulkan encoder\n");
- return VK_ERROR_DEVICE_LOST;
- }
-
- return VK_SUCCESS;
-}
-
-#define VK_HOST_CONNECTION(ret) \
- HostConnection* hostCon = HostConnection::getOrCreate(kCapsetGfxStreamVulkan); \
- gfxstream::vk::VkEncoder* vkEnc = hostCon->vkEncoder(); \
- if (!vkEnc) { \
- ALOGE("vulkan: Failed to get Vulkan encoder\n"); \
- return ret; \
- }
-
-VKAPI_ATTR
-VkResult EnumerateInstanceExtensionProperties(
- const char* layer_name,
- uint32_t* count,
- VkExtensionProperties* properties) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::EnumerateInstanceExtensionProperties");
-
- VkResult res = SetupInstance();
- if (res != VK_SUCCESS) {
- return res;
- }
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- if (layer_name) {
- ALOGW(
- "Driver vkEnumerateInstanceExtensionProperties shouldn't be called "
- "with a layer name ('%s')",
- layer_name);
- }
-
- res = gfxstream::vk::ResourceTracker::get()->on_vkEnumerateInstanceExtensionProperties(
- vkEnc, VK_SUCCESS, layer_name, count, properties);
-
- return res;
-}
-
-VKAPI_ATTR
-VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
- const VkAllocationCallbacks* allocator,
- VkInstance* out_instance) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::CreateInstance");
-
- VkResult res = SetupInstance();
- if (res != VK_SUCCESS) {
- return res;
- }
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
- res = vkEnc->vkCreateInstance(create_info, nullptr, out_instance, true /* do lock */);
-
- return res;
-}
-
-static PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::GetDeviceProcAddr");
-
- VK_HOST_CONNECTION(nullptr)
-
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (PFN_vkVoidFunction)(GetDeviceProcAddr);
- }
- return (PFN_vkVoidFunction)(gfxstream::vk::goldfish_vulkan_get_device_proc_address(device, name));
-}
-
-VKAPI_ATTR
-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::GetInstanceProcAddr");
-
- VkResult res = SetupInstance();
- if (res != VK_SUCCESS) {
- return nullptr;
- }
-
- VK_HOST_CONNECTION(nullptr)
-
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (PFN_vkVoidFunction)EnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkCreateInstance")) {
- return (PFN_vkVoidFunction)CreateInstance;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (PFN_vkVoidFunction)(GetDeviceProcAddr);
- }
- return (PFN_vkVoidFunction)(gfxstream::vk::goldfish_vulkan_get_instance_proc_address(instance, name));
-}
-
-#if defined(__ANDROID__)
-
-hwvulkan_device_t goldfish_vulkan_device = {
- .common = {
- .tag = HARDWARE_DEVICE_TAG,
- .version = HWVULKAN_DEVICE_API_VERSION_0_1,
- .module = &HAL_MODULE_INFO_SYM.common,
- .close = CloseDevice,
- },
- .EnumerateInstanceExtensionProperties = EnumerateInstanceExtensionProperties,
- .CreateInstance = CreateInstance,
- .GetInstanceProcAddr = GetInstanceProcAddr,
-};
-
-int OpenDevice(const hw_module_t* /*module*/,
- const char* id,
- hw_device_t** device) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::OpenDevice");
-
- if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
- *device = &goldfish_vulkan_device.common;
- gfxstream::vk::ResourceTracker::get();
- return 0;
- }
- return -ENOENT;
-}
-
-#elif VK_USE_PLATFORM_FUCHSIA
-
-class VulkanDevice {
-public:
- VulkanDevice() : mHostSupportsGoldfish(IsAccessible(QEMU_PIPE_PATH)) {
- InitLogger();
- InitTraceProvider();
- gfxstream::vk::ResourceTracker::get();
- }
-
- static void InitLogger();
-
- static bool IsAccessible(const char* name) {
- zx_handle_t handle = GetConnectToServiceFunction()(name);
- if (handle == ZX_HANDLE_INVALID)
- return false;
-
- zxio_storage_t io_storage;
- zx_status_t status = zxio_create(handle, &io_storage);
- if (status != ZX_OK)
- return false;
-
- status = zxio_close(&io_storage.io, /*should_wait=*/true);
- if (status != ZX_OK)
- return false;
-
- return true;
- }
-
- static VulkanDevice& GetInstance() {
- static VulkanDevice g_instance;
- return g_instance;
- }
-
- PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
- return ::GetInstanceProcAddr(instance, name);
- }
-
-private:
- void InitTraceProvider();
-
- TraceProviderFuchsia mTraceProvider;
- const bool mHostSupportsGoldfish;
-};
-
-void VulkanDevice::InitLogger() {
- auto log_socket = ([] () -> std::optional<zx::socket> {
- fidl::ClientEnd<fuchsia_logger::LogSink> channel{zx::channel{
- GetConnectToServiceFunction()("/svc/fuchsia.logger.LogSink")}};
- if (!channel.is_valid())
- return std::nullopt;
-
- zx::socket local_socket, remote_socket;
- zx_status_t status = zx::socket::create(ZX_SOCKET_DATAGRAM, &local_socket, &remote_socket);
- if (status != ZX_OK)
- return std::nullopt;
-
- auto result = fidl::WireCall(channel)->Connect(std::move(remote_socket));
-
- if (!result.ok())
- return std::nullopt;
-
- return local_socket;
- })();
- if (!log_socket)
- return;
-
- fx_logger_config_t config = {
- .min_severity = FX_LOG_INFO,
- .log_sink_socket = log_socket->release(),
- .tags = nullptr,
- .num_tags = 0,
- };
-
- fx_log_reconfigure(&config);
-}
-
-void VulkanDevice::InitTraceProvider() {
- if (!mTraceProvider.Initialize()) {
- ALOGE("Trace provider failed to initialize");
- }
-}
-
-extern "C" __attribute__((visibility("default"))) PFN_vkVoidFunction
-vk_icdGetInstanceProcAddr(VkInstance instance, const char* name) {
- return VulkanDevice::GetInstance().GetInstanceProcAddr(instance, name);
-}
-
-extern "C" __attribute__((visibility("default"))) VkResult
-vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) {
- *pSupportedVersion = std::min(*pSupportedVersion, 3u);
- return VK_SUCCESS;
-}
-
-typedef VkResult(VKAPI_PTR *PFN_vkOpenInNamespaceAddr)(const char *pName, uint32_t handle);
-
-namespace {
-
-PFN_vkOpenInNamespaceAddr g_vulkan_connector;
-
-zx_handle_t LocalConnectToServiceFunction(const char* pName) {
- zx::channel remote_endpoint, local_endpoint;
- zx_status_t status;
- if ((status = zx::channel::create(0, &remote_endpoint, &local_endpoint)) != ZX_OK) {
- ALOGE("zx::channel::create failed: %d", status);
- return ZX_HANDLE_INVALID;
- }
- if ((status = g_vulkan_connector(pName, remote_endpoint.release())) != ZX_OK) {
- ALOGE("vulkan_connector failed: %d", status);
- return ZX_HANDLE_INVALID;
- }
- return local_endpoint.release();
-}
-
-}
-
-extern "C" __attribute__((visibility("default"))) void
-vk_icdInitializeOpenInNamespaceCallback(PFN_vkOpenInNamespaceAddr callback) {
- g_vulkan_connector = callback;
- SetConnectToServiceFunction(&LocalConnectToServiceFunction);
-}
-
-#else
-class VulkanDevice {
-public:
- VulkanDevice() {
- gfxstream::vk::ResourceTracker::get();
- }
-
- static VulkanDevice& GetInstance() {
- static VulkanDevice g_instance;
- return g_instance;
- }
-
- PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
- return ::GetInstanceProcAddr(instance, name);
- }
-};
-
-extern "C" __attribute__((visibility("default"))) PFN_vkVoidFunction
-vk_icdGetInstanceProcAddr(VkInstance instance, const char* name) {
- return VulkanDevice::GetInstance().GetInstanceProcAddr(instance, name);
-}
-
-extern "C" __attribute__((visibility("default"))) VkResult
-vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) {
- *pSupportedVersion = std::min(*pSupportedVersion, 3u);
- return VK_SUCCESS;
-}
-
-#endif
-
-} // namespace
diff --git a/guest/vulkan/meson.build b/guest/vulkan/meson.build
index 5dc334a..0a4e163 100644
--- a/guest/vulkan/meson.build
+++ b/guest/vulkan/meson.build
@@ -1,23 +1,28 @@
# Copyright 2022 Android Open Source Project
# SPDX-License-Identifier: MIT
-vk_api_xml = files('vk.xml')
-vk_icd_gen = files('vk_icd_gen.py')
-
files_lib_vulkan_gfxstream = files(
- 'goldfish_vulkan.cpp',
+ 'gfxstream_vk_device.cpp',
+ 'gfxstream_vk_cmd.cpp',
+ 'gfxstream_vk_wsi.cpp'
)
lib_vulkan_gfxstream = shared_library(
'vulkan_gfxstream',
- files_lib_vulkan_gfxstream,
+ files_lib_vulkan_gfxstream + files_lib_vulkan_enc + gfxstream_vk_entrypoints,
cpp_args: cpp_args,
include_directories: [inc_vulkan_headers, inc_opengl_headers, inc_android_emu,
inc_android_compat, inc_opengl_system, inc_guest_iostream,
inc_opengl_codec, inc_render_enc, inc_vulkan_enc, inc_platform,
- inc_goldfish_address_space, inc_system, inc_codec_common],
+ inc_goldfish_address_space, inc_system, inc_include, inc_src,
+ inc_platform, inc_codec_common],
link_with: [lib_android_compat, lib_emu_android_base, lib_stream,
- lib_vulkan_enc, libvulkan_wsi],
+ libvulkan_wsi, lib_platform],
+ link_args: [vulkan_icd_link_args, ld_args_bsymbolic, ld_args_gc_sections],
+ link_depends: vulkan_icd_link_depends,
+ dependencies: [dependency('libdrm'), idep_vulkan_wsi_headers,
+ idep_vulkan_runtime_headers, idep_vulkan_runtime,
+ idep_vulkan_util_headers, idep_vulkan_wsi],
install: true,
)
@@ -27,7 +32,7 @@
output : 'gfxstream_icd.@[email protected]'.format(host_machine.cpu()),
command : [
prog_python, '@INPUT0@',
- '--api-version', '1.0', '--xml', '@INPUT1@',
+ '--api-version', '1.1', '--xml', '@INPUT1@',
'--lib-path', join_paths(get_option('prefix'), get_option('libdir'),
'libvulkan_gfxstream.so'),
'--out', '@OUTPUT@',
diff --git a/guest/vulkan/vk.xml b/guest/vulkan/vk.xml
deleted file mode 100644
index a16e039..0000000
--- a/guest/vulkan/vk.xml
+++ /dev/null
@@ -1,18288 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<registry>
- <comment>
-Copyright 2015-2021 The Khronos Group Inc.
-
-SPDX-License-Identifier: Apache-2.0 OR MIT
- </comment>
-
- <comment>
-This file, vk.xml, is the Vulkan API Registry. It is a critically important
-and normative part of the Vulkan Specification, including a canonical
-machine-readable definition of the API, parameter and member validation
-language incorporated into the Specification and reference pages, and other
-material which is registered by Khronos, such as tags used by extension and
-layer authors. The authoritative public version of vk.xml is maintained in
-the default branch (currently named main) of the Khronos Vulkan GitHub
-project. The authoritative private version is maintained in the default
-branch of the member gitlab server.
- </comment>
-
- <platforms comment="Vulkan platform names, reserved for use with platform- and window system-specific extensions">
- <platform name="xlib" protect="VK_USE_PLATFORM_XLIB_KHR" comment="X Window System, Xlib client library"/>
- <platform name="xlib_xrandr" protect="VK_USE_PLATFORM_XLIB_XRANDR_EXT" comment="X Window System, Xlib client library, XRandR extension"/>
- <platform name="xcb" protect="VK_USE_PLATFORM_XCB_KHR" comment="X Window System, Xcb client library"/>
- <platform name="wayland" protect="VK_USE_PLATFORM_WAYLAND_KHR" comment="Wayland display server protocol"/>
- <platform name="directfb" protect="VK_USE_PLATFORM_DIRECTFB_EXT" comment="DirectFB library"/>
- <platform name="android" protect="VK_USE_PLATFORM_ANDROID_KHR" comment="Android OS"/>
- <platform name="win32" protect="VK_USE_PLATFORM_WIN32_KHR" comment="Microsoft Win32 API (also refers to Win64 apps)"/>
- <platform name="vi" protect="VK_USE_PLATFORM_VI_NN" comment="Nintendo Vi"/>
- <platform name="ios" protect="VK_USE_PLATFORM_IOS_MVK" comment="Apple IOS"/>
- <platform name="macos" protect="VK_USE_PLATFORM_MACOS_MVK" comment="Apple MacOS"/>
- <platform name="metal" protect="VK_USE_PLATFORM_METAL_EXT" comment="Metal on CoreAnimation on Apple platforms"/>
- <platform name="fuchsia" protect="VK_USE_PLATFORM_FUCHSIA" comment="Fuchsia"/>
- <platform name="ggp" protect="VK_USE_PLATFORM_GGP" comment="Google Games Platform"/>
- <platform name="provisional" protect="VK_ENABLE_BETA_EXTENSIONS" comment="Enable declarations for beta/provisional extensions"/>
- <platform name="screen" protect="VK_USE_PLATFORM_SCREEN_QNX" comment="QNX Screen Graphics Subsystem"/>
- </platforms>
-
- <tags comment="Vulkan vendor/author tags for extensions and layers">
- <tag name="IMG" author="Imagination Technologies" contact="Michael Worcester @michaelworcester"/>
- <tag name="AMD" author="Advanced Micro Devices, Inc." contact="Daniel Rakos @drakos-amd"/>
- <tag name="AMDX" author="Advanced Micro Devices, Inc." contact="Daniel Rakos @drakos-amd"/>
- <tag name="ARM" author="ARM Limited" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm"/>
- <tag name="FSL" author="Freescale Semiconductor, Inc." contact="Norbert Nopper @FslNopper"/>
- <tag name="BRCM" author="Broadcom Corporation" contact="Graeme Leese @gnl21"/>
- <tag name="NXP" author="NXP Semiconductors N.V." contact="Norbert Nopper @FslNopper"/>
- <tag name="NV" author="NVIDIA Corporation" contact="Daniel Koch @dgkoch"/>
- <tag name="NVX" author="NVIDIA Corporation" contact="Daniel Koch @dgkoch"/>
- <tag name="VIV" author="Vivante Corporation" contact="Yanjun Zhang gitlab:@yanjunzhang"/>
- <tag name="VSI" author="VeriSilicon Holdings Co., Ltd." contact="Yanjun Zhang gitlab:@yanjunzhang"/>
- <tag name="KDAB" author="KDAB" contact="Sean Harmer @seanharmer"/>
- <tag name="ANDROID" author="Google LLC" contact="Jesse Hall @critsec"/>
- <tag name="CHROMIUM" author="Google LLC" contact="Jesse Hall @critsec"/>
- <tag name="FUCHSIA" author="Google LLC" contact="Craig Stout @cdotstout, Jesse Hall @critsec, John Rosasco @rosasco"/>
- <tag name="GGP" author="Google, LLC" contact="Jean-Francois Roy @jfroy, Hai Nguyen @chaoticbob, Jesse Hall @critsec"/>
- <tag name="GOOGLE" author="Google LLC" contact="Jesse Hall @critsec"/>
- <tag name="QCOM" author="Qualcomm Technologies, Inc." contact="Jeff Leger @jackohounhd"/>
- <tag name="LUNARG" author="LunarG, Inc." contact="Karen Ghavam @karenghavam-lunarg"/>
- <tag name="SAMSUNG" author="Samsung Electronics Co., Ltd." contact="Alon Or-bach @alonorbach"/>
- <tag name="SEC" author="Samsung Electronics Co., Ltd." contact="Alon Or-bach @alonorbach"/>
- <tag name="TIZEN" author="Samsung Electronics Co., Ltd." contact="Alon Or-bach @alonorbach"/>
- <tag name="RENDERDOC" author="RenderDoc (renderdoc.org)" contact="Baldur Karlsson @baldurk"/>
- <tag name="NN" author="Nintendo Co., Ltd." contact="Yasuhiro Yoshioka gitlab:@yoshioka_yasuhiro"/>
- <tag name="MVK" author="The Brenwill Workshop Ltd." contact="Bill Hollings @billhollings"/>
- <tag name="KHR" author="Khronos" contact="Tom Olson @tomolson"/>
- <tag name="KHX" author="Khronos" contact="Tom Olson @tomolson"/>
- <tag name="EXT" author="Multivendor" contact="Jon Leech @oddhack"/>
- <tag name="MESA" author="Mesa open source project" contact="Chad Versace @chadversary, Daniel Stone @fooishbar, David Airlie @airlied, Jason Ekstrand @jekstrand"/>
- <tag name="INTEL" author="Intel Corporation" contact="Slawek Grajewski @sgrajewski"/>
- <tag name="HUAWEI" author="Huawei Technologies Co. Ltd." contact="Hueilong Wang @wyvernathuawei, Yunpeng Zhu @yunxingzhu"/>
- <tag name="VALVE" author="Valve Corporation" contact="Pierre-Loup Griffais @plagman, Joshua Ashton @Joshua-Ashton, Hans-Kristian Arntzen @HansKristian-Work"/>
- <tag name="QNX" author="BlackBerry Limited" contact="Mike Gorchak @mgorchak-blackberry"/>
- <tag name="JUICE" author="Juice Technologies, Inc." contact="David McCloskey @damcclos, Dean Beeler @canadacow"/>
- <tag name="FB" author="Facebook, Inc" contact="Artem Bolgar @artyom17"/>
- </tags>
-
- <types comment="Vulkan type definitions">
- <type name="vk_platform" category="include">#include "vk_platform.h"</type>
-
- <comment>WSI extensions</comment>
-
- <type category="include" name="X11/Xlib.h"/>
- <type category="include" name="X11/extensions/Xrandr.h"/>
- <type category="include" name="wayland-client.h"/>
- <type category="include" name="windows.h"/>
- <type category="include" name="xcb/xcb.h"/>
- <type category="include" name="directfb.h"/>
- <type category="include" name="zircon/types.h"/>
- <type category="include" name="ggp_c/vulkan_types.h"/>
- <type category="include" name="screen/screen.h"/>
- <comment>
- In the current header structure, each platform's interfaces
- are confined to a platform-specific header (vulkan_xlib.h,
- vulkan_win32.h, etc.). These headers are not self-contained,
- and should not include native headers (X11/Xlib.h,
- windows.h, etc.). Code should either include vulkan.h after
- defining the appropriate VK_USE_PLATFORM_platform
- macros, or include the required native headers prior to
- explicitly including the corresponding platform header.
-
- To accomplish this, the dependencies of native types require
- native headers, but the XML defines the content for those
- native headers as empty. The actual native header includes
- can be restored by modifying the native header tags above
- to #include the header file in the 'name' attribute.
- </comment>
-
- <type requires="X11/Xlib.h" name="Display"/>
- <type requires="X11/Xlib.h" name="VisualID"/>
- <type requires="X11/Xlib.h" name="Window"/>
- <type requires="X11/extensions/Xrandr.h" name="RROutput"/>
- <type requires="wayland-client.h" name="wl_display"/>
- <type requires="wayland-client.h" name="wl_surface"/>
- <type requires="windows.h" name="HINSTANCE"/>
- <type requires="windows.h" name="HWND"/>
- <type requires="windows.h" name="HMONITOR"/>
- <type requires="windows.h" name="HANDLE"/>
- <type requires="windows.h" name="SECURITY_ATTRIBUTES"/>
- <type requires="windows.h" name="DWORD"/>
- <type requires="windows.h" name="LPCWSTR"/>
- <type requires="xcb/xcb.h" name="xcb_connection_t"/>
- <type requires="xcb/xcb.h" name="xcb_visualid_t"/>
- <type requires="xcb/xcb.h" name="xcb_window_t"/>
- <type requires="directfb.h" name="IDirectFB"/>
- <type requires="directfb.h" name="IDirectFBSurface"/>
- <type requires="zircon/types.h" name="zx_handle_t"/>
- <type requires="ggp_c/vulkan_types.h" name="GgpStreamDescriptor"/>
- <type requires="ggp_c/vulkan_types.h" name="GgpFrameToken"/>
- <type requires="screen/screen.h" name="_screen_context"/>
- <type requires="screen/screen.h" name="_screen_window"/>
-
- <type category="define">// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.
-#define <name>VK_MAKE_VERSION</name>(major, minor, patch) \
- ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))</type>
- <type category="define">// DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead.
-#define <name>VK_VERSION_MAJOR</name>(version) ((uint32_t)(version) >> 22)</type>
- <type category="define">// DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead.
-#define <name>VK_VERSION_MINOR</name>(version) (((uint32_t)(version) >> 12) & 0x3FFU)</type>
- <type category="define">// DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead.
-#define <name>VK_VERSION_PATCH</name>(version) ((uint32_t)(version) & 0xFFFU)</type>
-
- <type category="define">#define <name>VK_MAKE_API_VERSION</name>(variant, major, minor, patch) \
- ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))</type>
- <type category="define">#define <name>VK_API_VERSION_VARIANT</name>(version) ((uint32_t)(version) >> 29)</type>
- <type category="define">#define <name>VK_API_VERSION_MAJOR</name>(version) (((uint32_t)(version) >> 22) & 0x7FU)</type>
- <type category="define">#define <name>VK_API_VERSION_MINOR</name>(version) (((uint32_t)(version) >> 12) & 0x3FFU)</type>
- <type category="define">#define <name>VK_API_VERSION_PATCH</name>(version) ((uint32_t)(version) & 0xFFFU)</type>
-
- <type category="define">// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
-//#define <name>VK_API_VERSION</name> <type>VK_MAKE_VERSION</type>(1, 0, 0) // Patch version should always be set to 0</type>
- <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.0 version number
-#define <name>VK_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 0, 0)// Patch version should always be set to 0</type>
- <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.1 version number
-#define <name>VK_API_VERSION_1_1</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 1, 0)// Patch version should always be set to 0</type>
- <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.2 version number
-#define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, 0)// Patch version should always be set to 0</type>
- <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 198</type>
- <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
-#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, VK_HEADER_VERSION)</type>
-
- <type category="define">
-#define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
-
- <type category="define" name="VK_USE_64_BIT_PTR_DEFINES">
-#ifndef VK_USE_64_BIT_PTR_DEFINES
- #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
- #define VK_USE_64_BIT_PTR_DEFINES 1
- #else
- #define VK_USE_64_BIT_PTR_DEFINES 0
- #endif
-#endif</type>
- <type category="define" requires="VK_USE_64_BIT_PTR_DEFINES" name="VK_NULL_HANDLE">
-#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
- #if (VK_USE_64_BIT_PTR_DEFINES==1)
- #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L))
- #define VK_NULL_HANDLE nullptr
- #else
- #define VK_NULL_HANDLE ((void*)0)
- #endif
- #else
- #define VK_NULL_HANDLE 0ULL
- #endif
-#endif
-#ifndef VK_NULL_HANDLE
- #define VK_NULL_HANDLE 0
-#endif</type>
- <type category="define" requires="VK_NULL_HANDLE" name="VK_DEFINE_NON_DISPATCHABLE_HANDLE">
-#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
- #if (VK_USE_64_BIT_PTR_DEFINES==1)
- #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
- #else
- #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
- #endif
-#endif</type>
-
- <type category="basetype">struct <name>ANativeWindow</name>;</type>
- <type category="basetype">struct <name>AHardwareBuffer</name>;</type>
- <type category="basetype">
-#ifdef __OBJC__
-@class CAMetalLayer;
-#else
-typedef void <name>CAMetalLayer</name>;
-#endif</type>
-
- <type category="basetype">typedef <type>uint32_t</type> <name>VkSampleMask</name>;</type>
- <type category="basetype">typedef <type>uint32_t</type> <name>VkBool32</name>;</type>
- <type category="basetype">typedef <type>uint32_t</type> <name>VkFlags</name>;</type>
- <type category="basetype">typedef <type>uint64_t</type> <name>VkFlags64</name>;</type>
- <type category="basetype">typedef <type>uint64_t</type> <name>VkDeviceSize</name>;</type>
- <type category="basetype">typedef <type>uint64_t</type> <name>VkDeviceAddress</name>;</type>
-
- <comment>Basic C types, pulled in via vk_platform.h</comment>
- <type requires="vk_platform" name="void"/>
- <type requires="vk_platform" name="char"/>
- <type requires="vk_platform" name="float"/>
- <type requires="vk_platform" name="double"/>
- <type requires="vk_platform" name="int8_t"/>
- <type requires="vk_platform" name="uint8_t"/>
- <type requires="vk_platform" name="int16_t"/>
- <type requires="vk_platform" name="uint16_t"/>
- <type requires="vk_platform" name="uint32_t"/>
- <type requires="vk_platform" name="uint64_t"/>
- <type requires="vk_platform" name="int32_t"/>
- <type requires="vk_platform" name="int64_t"/>
- <type requires="vk_platform" name="size_t"/>
- <type name="int"/>
-
- <comment>Bitmask types</comment>
- <type requires="VkFramebufferCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkFramebufferCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkQueryPoolCreateFlags</name>;</type>
- <type requires="VkRenderPassCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkRenderPassCreateFlags</name>;</type>
- <type requires="VkSamplerCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSamplerCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineLayoutCreateFlags</name>;</type>
- <type requires="VkPipelineCacheCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCacheCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineDepthStencilStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineDynamicStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineColorBlendStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineMultisampleStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineViewportStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineTessellationStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineInputAssemblyStateCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineVertexInputStateCreateFlags</name>;</type>
- <type requires="VkPipelineShaderStageCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineShaderStageCreateFlags</name>;</type>
- <type requires="VkDescriptorSetLayoutCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorSetLayoutCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkBufferViewCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkInstanceCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceCreateFlags</name>;</type>
- <type requires="VkDeviceQueueCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceQueueCreateFlags</name>;</type>
- <type requires="VkQueueFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkQueueFlags</name>;</type>
- <type requires="VkMemoryPropertyFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryPropertyFlags</name>;</type>
- <type requires="VkMemoryHeapFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryHeapFlags</name>;</type>
- <type requires="VkAccessFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkAccessFlags</name>;</type>
- <type requires="VkBufferUsageFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkBufferUsageFlags</name>;</type>
- <type requires="VkBufferCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkBufferCreateFlags</name>;</type>
- <type requires="VkShaderStageFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkShaderStageFlags</name>;</type>
- <type requires="VkImageUsageFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkImageUsageFlags</name>;</type>
- <type requires="VkImageCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkImageCreateFlags</name>;</type>
- <type requires="VkImageViewCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkImageViewCreateFlags</name>;</type>
- <type requires="VkPipelineCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCreateFlags</name>;</type>
- <type requires="VkColorComponentFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkColorComponentFlags</name>;</type>
- <type requires="VkFenceCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkFenceCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkSemaphoreCreateFlags</name>;</type>
- <type requires="VkFormatFeatureFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkFormatFeatureFlags</name>;</type>
- <type requires="VkQueryControlFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkQueryControlFlags</name>;</type>
- <type requires="VkQueryResultFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkQueryResultFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkShaderModuleCreateFlags</name>;</type>
- <type requires="VkEventCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkEventCreateFlags</name>;</type>
- <type requires="VkCommandPoolCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkCommandPoolCreateFlags</name>;</type>
- <type requires="VkCommandPoolResetFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkCommandPoolResetFlags</name>;</type>
- <type requires="VkCommandBufferResetFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkCommandBufferResetFlags</name>;</type>
- <type requires="VkCommandBufferUsageFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkCommandBufferUsageFlags</name>;</type>
- <type requires="VkQueryPipelineStatisticFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkQueryPipelineStatisticFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryMapFlags</name>;</type>
- <type requires="VkImageAspectFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkImageAspectFlags</name>;</type>
- <type requires="VkSparseMemoryBindFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSparseMemoryBindFlags</name>;</type>
- <type requires="VkSparseImageFormatFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSparseImageFormatFlags</name>;</type>
- <type requires="VkSubpassDescriptionFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSubpassDescriptionFlags</name>;</type>
- <type requires="VkPipelineStageFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineStageFlags</name>;</type>
- <type requires="VkSampleCountFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSampleCountFlags</name>;</type>
- <type requires="VkAttachmentDescriptionFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkAttachmentDescriptionFlags</name>;</type>
- <type requires="VkStencilFaceFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkStencilFaceFlags</name>;</type>
- <type requires="VkCullModeFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkCullModeFlags</name>;</type>
- <type requires="VkDescriptorPoolCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorPoolCreateFlags</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorPoolResetFlags</name>;</type>
- <type requires="VkDependencyFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDependencyFlags</name>;</type>
- <type requires="VkSubgroupFeatureFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSubgroupFeatureFlags</name>;</type>
- <type requires="VkIndirectCommandsLayoutUsageFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkIndirectCommandsLayoutUsageFlagsNV</name>;</type>
- <type requires="VkIndirectStateFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkIndirectStateFlagsNV</name>;</type>
- <type requires="VkGeometryFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkGeometryFlagsKHR</name>;</type>
- <type category="bitmask" name="VkGeometryFlagsNV" alias="VkGeometryFlagsKHR"/>
- <type requires="VkGeometryInstanceFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkGeometryInstanceFlagsKHR</name>;</type>
- <type category="bitmask" name="VkGeometryInstanceFlagsNV" alias="VkGeometryInstanceFlagsKHR"/>
- <type requires="VkBuildAccelerationStructureFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkBuildAccelerationStructureFlagsKHR</name>;</type>
- <type category="bitmask" name="VkBuildAccelerationStructureFlagsNV" alias="VkBuildAccelerationStructureFlagsKHR"/>
- <type requires="VkPrivateDataSlotCreateFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkPrivateDataSlotCreateFlagsEXT</name>;</type>
- <type requires="VkAccelerationStructureCreateFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkAccelerationStructureCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorUpdateTemplateCreateFlags</name>;</type>
- <type category="bitmask" name="VkDescriptorUpdateTemplateCreateFlagsKHR" alias="VkDescriptorUpdateTemplateCreateFlags"/>
- <type requires="VkPipelineCreationFeedbackFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCreationFeedbackFlagsEXT</name>;</type>
- <type requires="VkPerformanceCounterDescriptionFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkPerformanceCounterDescriptionFlagsKHR</name>;</type>
- <type requires="VkAcquireProfilingLockFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkAcquireProfilingLockFlagsKHR</name>;</type>
- <type requires="VkSemaphoreWaitFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSemaphoreWaitFlags</name>;</type>
- <type category="bitmask" name="VkSemaphoreWaitFlagsKHR" alias="VkSemaphoreWaitFlags"/>
- <type requires="VkPipelineCompilerControlFlagBitsAMD" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCompilerControlFlagsAMD</name>;</type>
- <type requires="VkShaderCorePropertiesFlagBitsAMD" category="bitmask">typedef <type>VkFlags</type> <name>VkShaderCorePropertiesFlagsAMD</name>;</type>
- <type requires="VkDeviceDiagnosticsConfigFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceDiagnosticsConfigFlagsNV</name>;</type>
- <type bitvalues="VkAccessFlagBits2KHR" category="bitmask">typedef <type>VkFlags64</type> <name>VkAccessFlags2KHR</name>;</type>
- <type bitvalues="VkPipelineStageFlagBits2KHR" category="bitmask">typedef <type>VkFlags64</type> <name>VkPipelineStageFlags2KHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkAccelerationStructureMotionInfoFlagsNV</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkAccelerationStructureMotionInstanceFlagsNV</name>;</type>
- <type bitvalues="VkFormatFeatureFlagBits2KHR" category="bitmask">typedef <type>VkFlags64</type> <name>VkFormatFeatureFlags2KHR</name>;</type>
- <type requires="VkRenderingFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkRenderingFlagsKHR</name>;</type>
-
- <comment>WSI extensions</comment>
- <type requires="VkCompositeAlphaFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkCompositeAlphaFlagsKHR</name>;</type>
- <type requires="VkDisplayPlaneAlphaFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkDisplayPlaneAlphaFlagsKHR</name>;</type>
- <type requires="VkSurfaceTransformFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkSurfaceTransformFlagsKHR</name>;</type>
- <type requires="VkSwapchainCreateFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkSwapchainCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDisplayModeCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDisplaySurfaceCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkAndroidSurfaceCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkViSurfaceCreateFlagsNN</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkWaylandSurfaceCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkWin32SurfaceCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkXlibSurfaceCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkXcbSurfaceCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDirectFBSurfaceCreateFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkIOSSurfaceCreateFlagsMVK</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkMacOSSurfaceCreateFlagsMVK</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkMetalSurfaceCreateFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkImagePipeSurfaceCreateFlagsFUCHSIA</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkStreamDescriptorSurfaceCreateFlagsGGP</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkHeadlessSurfaceCreateFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkScreenSurfaceCreateFlagsQNX</name>;</type>
- <type requires="VkPeerMemoryFeatureFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkPeerMemoryFeatureFlags</name>;</type>
- <type category="bitmask" name="VkPeerMemoryFeatureFlagsKHR" alias="VkPeerMemoryFeatureFlags"/>
- <type requires="VkMemoryAllocateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryAllocateFlags</name>;</type>
- <type category="bitmask" name="VkMemoryAllocateFlagsKHR" alias="VkMemoryAllocateFlags"/>
- <type requires="VkDeviceGroupPresentModeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceGroupPresentModeFlagsKHR</name>;</type>
-
- <type requires="VkDebugReportFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkDebugReportFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkCommandPoolTrimFlags</name>;</type>
- <type category="bitmask" name="VkCommandPoolTrimFlagsKHR" alias="VkCommandPoolTrimFlags"/>
- <type requires="VkExternalMemoryHandleTypeFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryHandleTypeFlagsNV</name>;</type>
- <type requires="VkExternalMemoryFeatureFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryFeatureFlagsNV</name>;</type>
- <type requires="VkExternalMemoryHandleTypeFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryHandleTypeFlags</name>;</type>
- <type category="bitmask" name="VkExternalMemoryHandleTypeFlagsKHR" alias="VkExternalMemoryHandleTypeFlags"/>
- <type requires="VkExternalMemoryFeatureFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryFeatureFlags</name>;</type>
- <type category="bitmask" name="VkExternalMemoryFeatureFlagsKHR" alias="VkExternalMemoryFeatureFlags"/>
- <type requires="VkExternalSemaphoreHandleTypeFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreHandleTypeFlags</name>;</type>
- <type category="bitmask" name="VkExternalSemaphoreHandleTypeFlagsKHR" alias="VkExternalSemaphoreHandleTypeFlags"/>
- <type requires="VkExternalSemaphoreFeatureFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreFeatureFlags</name>;</type>
- <type category="bitmask" name="VkExternalSemaphoreFeatureFlagsKHR" alias="VkExternalSemaphoreFeatureFlags"/>
- <type requires="VkSemaphoreImportFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSemaphoreImportFlags</name>;</type>
- <type category="bitmask" name="VkSemaphoreImportFlagsKHR" alias="VkSemaphoreImportFlags"/>
- <type requires="VkExternalFenceHandleTypeFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalFenceHandleTypeFlags</name>;</type>
- <type category="bitmask" name="VkExternalFenceHandleTypeFlagsKHR" alias="VkExternalFenceHandleTypeFlags"/>
- <type requires="VkExternalFenceFeatureFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalFenceFeatureFlags</name>;</type>
- <type category="bitmask" name="VkExternalFenceFeatureFlagsKHR" alias="VkExternalFenceFeatureFlags"/>
- <type requires="VkFenceImportFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkFenceImportFlags</name>;</type>
- <type category="bitmask" name="VkFenceImportFlagsKHR" alias="VkFenceImportFlags"/>
- <type requires="VkSurfaceCounterFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkSurfaceCounterFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineViewportSwizzleStateCreateFlagsNV</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineDiscardRectangleStateCreateFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCoverageToColorStateCreateFlagsNV</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCoverageModulationStateCreateFlagsNV</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCoverageReductionStateCreateFlagsNV</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkValidationCacheCreateFlagsEXT</name>;</type>
- <type requires="VkDebugUtilsMessageSeverityFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkDebugUtilsMessageSeverityFlagsEXT</name>;</type>
- <type requires="VkDebugUtilsMessageTypeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkDebugUtilsMessageTypeFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDebugUtilsMessengerCreateFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDebugUtilsMessengerCallbackDataFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceMemoryReportFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationConservativeStateCreateFlagsEXT</name>;</type>
- <type requires="VkDescriptorBindingFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorBindingFlags</name>;</type>
- <type category="bitmask" name="VkDescriptorBindingFlagsEXT" alias="VkDescriptorBindingFlags"/>
- <type requires="VkConditionalRenderingFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkConditionalRenderingFlagsEXT</name>;</type>
- <type requires="VkResolveModeFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkResolveModeFlags</name>;</type>
- <type category="bitmask" name="VkResolveModeFlagsKHR" alias="VkResolveModeFlags"/>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationStateStreamCreateFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationDepthClipStateCreateFlagsEXT</name>;</type>
- <type requires="VkToolPurposeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkToolPurposeFlagsEXT</name>;</type>
- <type requires="VkSubmitFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkSubmitFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkImageFormatConstraintsFlagsFUCHSIA</name>;</type>
- <type requires="VkImageConstraintsInfoFlagBitsFUCHSIA" category="bitmask">typedef <type>VkFlags</type> <name>VkImageConstraintsInfoFlagsFUCHSIA</name>;</type>
-
- <comment>Video Core extension</comment>
- <type requires="VkVideoCodecOperationFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCodecOperationFlagsKHR</name>;</type>
- <type requires="VkVideoCapabilityFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCapabilityFlagsKHR</name>;</type>
- <type requires="VkVideoSessionCreateFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoSessionCreateFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoBeginCodingFlagsKHR</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEndCodingFlagsKHR</name>;</type>
- <type requires="VkVideoCodingQualityPresetFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCodingQualityPresetFlagsKHR</name>;</type>
- <type requires="VkVideoCodingControlFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCodingControlFlagsKHR</name>;</type>
-
- <comment>Video Decode Core extension</comment>
- <type requires="VkVideoDecodeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeFlagsKHR</name>;</type>
-
- <comment>Video Decode H.264 extension</comment>
- <type requires="VkVideoDecodeH264PictureLayoutFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264PictureLayoutFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264CreateFlagsEXT</name>;</type>
-
- <comment>Video Decode H.265 extension</comment>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH265CreateFlagsEXT</name>;</type>
-
- <comment>Video Encode Core extension</comment>
- <type requires="VkVideoEncodeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeFlagsKHR</name>;</type>
- <type requires="VkVideoEncodeRateControlFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeRateControlFlagsKHR</name>;</type>
- <type requires="VkVideoEncodeRateControlModeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeRateControlModeFlagsKHR</name>;</type>
- <type requires="VkVideoChromaSubsamplingFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoChromaSubsamplingFlagsKHR</name>;</type>
- <type requires="VkVideoComponentBitDepthFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoComponentBitDepthFlagsKHR</name>;</type>
-
- <comment>Video Encode H.264 extension</comment>
- <type requires="VkVideoEncodeH264CapabilityFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CapabilityFlagsEXT</name>;</type>
- <type requires="VkVideoEncodeH264InputModeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264InputModeFlagsEXT</name>;</type>
- <type requires="VkVideoEncodeH264OutputModeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264OutputModeFlagsEXT</name>;</type>
- <type requires="VkVideoEncodeH264CreateFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CreateFlagsEXT</name>;</type>
-
- <comment>Video Encode H.265 extension</comment>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265CapabilityFlagsEXT</name>;</type>
- <type requires="VkVideoEncodeH265InputModeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265InputModeFlagsEXT</name>;</type>
- <type requires="VkVideoEncodeH265OutputModeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265OutputModeFlagsEXT</name>;</type>
- <type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265CreateFlagsEXT</name>;</type>
- <type requires="VkVideoEncodeH265CtbSizeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265CtbSizeFlagsEXT</name>;</type>
-
- <comment>Types which can be void pointers or class pointers, selected at compile time</comment>
- <type category="handle" objtypeenum="VK_OBJECT_TYPE_INSTANCE"><type>VK_DEFINE_HANDLE</type>(<name>VkInstance</name>)</type>
- <type category="handle" parent="VkInstance" objtypeenum="VK_OBJECT_TYPE_PHYSICAL_DEVICE"><type>VK_DEFINE_HANDLE</type>(<name>VkPhysicalDevice</name>)</type>
- <type category="handle" parent="VkPhysicalDevice" objtypeenum="VK_OBJECT_TYPE_DEVICE"><type>VK_DEFINE_HANDLE</type>(<name>VkDevice</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_QUEUE"><type>VK_DEFINE_HANDLE</type>(<name>VkQueue</name>)</type>
- <type category="handle" parent="VkCommandPool" objtypeenum="VK_OBJECT_TYPE_COMMAND_BUFFER"><type>VK_DEFINE_HANDLE</type>(<name>VkCommandBuffer</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_DEVICE_MEMORY"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDeviceMemory</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_COMMAND_POOL"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkCommandPool</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_BUFFER"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkBuffer</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_BUFFER_VIEW"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkBufferView</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_IMAGE"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkImage</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_IMAGE_VIEW"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkImageView</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_SHADER_MODULE"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkShaderModule</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_PIPELINE"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkPipeline</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_PIPELINE_LAYOUT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkPipelineLayout</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_SAMPLER"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkSampler</name>)</type>
- <type category="handle" parent="VkDescriptorPool" objtypeenum="VK_OBJECT_TYPE_DESCRIPTOR_SET"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDescriptorSet</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDescriptorSetLayout</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_DESCRIPTOR_POOL"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDescriptorPool</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_FENCE"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkFence</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_SEMAPHORE"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkSemaphore</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_EVENT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkEvent</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_QUERY_POOL"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkQueryPool</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_FRAMEBUFFER"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkFramebuffer</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_RENDER_PASS"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkRenderPass</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_PIPELINE_CACHE"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkPipelineCache</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkIndirectCommandsLayoutNV</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDescriptorUpdateTemplate</name>)</type>
- <type category="handle" name="VkDescriptorUpdateTemplateKHR" alias="VkDescriptorUpdateTemplate"/>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkSamplerYcbcrConversion</name>)</type>
- <type category="handle" name="VkSamplerYcbcrConversionKHR" alias="VkSamplerYcbcrConversion"/>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkValidationCacheEXT</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkAccelerationStructureKHR</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkAccelerationStructureNV</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkPerformanceConfigurationINTEL</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkBufferCollectionFUCHSIA</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDeferredOperationKHR</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkPrivateDataSlotEXT</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_CU_MODULE_NVX"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkCuModuleNVX</name>)</type>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_CU_FUNCTION_NVX"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkCuFunctionNVX</name>)</type>
-
- <comment>WSI extensions</comment>
- <type category="handle" parent="VkPhysicalDevice" objtypeenum="VK_OBJECT_TYPE_DISPLAY_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDisplayKHR</name>)</type>
- <type category="handle" parent="VkDisplayKHR" objtypeenum="VK_OBJECT_TYPE_DISPLAY_MODE_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDisplayModeKHR</name>)</type>
- <type category="handle" parent="VkInstance" objtypeenum="VK_OBJECT_TYPE_SURFACE_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkSurfaceKHR</name>)</type>
- <type category="handle" parent="VkSurfaceKHR" objtypeenum="VK_OBJECT_TYPE_SWAPCHAIN_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkSwapchainKHR</name>)</type>
- <type category="handle" parent="VkInstance" objtypeenum="VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDebugReportCallbackEXT</name>)</type>
- <type category="handle" parent="VkInstance" objtypeenum="VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDebugUtilsMessengerEXT</name>)</type>
-
- <comment>Video extensions</comment>
- <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_VIDEO_SESSION_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkVideoSessionKHR</name>)</type>
- <type category="handle" parent="VkVideoSessionKHR" objtypeenum="VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkVideoSessionParametersKHR</name>)</type>
-
- <comment>Types generated from corresponding enums tags below</comment>
- <type name="VkAttachmentLoadOp" category="enum"/>
- <type name="VkAttachmentStoreOp" category="enum"/>
- <type name="VkBlendFactor" category="enum"/>
- <type name="VkBlendOp" category="enum"/>
- <type name="VkBorderColor" category="enum"/>
- <type name="VkFramebufferCreateFlagBits" category="enum"/>
- <type name="VkQueryPoolCreateFlagBits" category="enum"/>
- <type name="VkRenderPassCreateFlagBits" category="enum"/>
- <type name="VkSamplerCreateFlagBits" category="enum"/>
- <type name="VkPipelineCacheHeaderVersion" category="enum"/>
- <type name="VkPipelineCacheCreateFlagBits" category="enum"/>
- <type name="VkPipelineShaderStageCreateFlagBits" category="enum"/>
- <type name="VkDescriptorSetLayoutCreateFlagBits" category="enum"/>
- <type name="VkInstanceCreateFlagBits" category="enum"/>
- <type name="VkDeviceQueueCreateFlagBits" category="enum"/>
- <type name="VkBufferCreateFlagBits" category="enum"/>
- <type name="VkBufferUsageFlagBits" category="enum"/>
- <type name="VkColorComponentFlagBits" category="enum"/>
- <type name="VkComponentSwizzle" category="enum"/>
- <type name="VkCommandPoolCreateFlagBits" category="enum"/>
- <type name="VkCommandPoolResetFlagBits" category="enum"/>
- <type name="VkCommandBufferResetFlagBits" category="enum"/>
- <type name="VkCommandBufferLevel" category="enum"/>
- <type name="VkCommandBufferUsageFlagBits" category="enum"/>
- <type name="VkCompareOp" category="enum"/>
- <type name="VkCullModeFlagBits" category="enum"/>
- <type name="VkDescriptorType" category="enum"/>
- <type name="VkDeviceCreateFlagBits" category="enum"/>
- <type name="VkDynamicState" category="enum"/>
- <type name="VkFenceCreateFlagBits" category="enum"/>
- <type name="VkPolygonMode" category="enum"/>
- <type name="VkFormat" category="enum"/>
- <type name="VkFormatFeatureFlagBits" category="enum"/>
- <type name="VkFrontFace" category="enum"/>
- <type name="VkImageAspectFlagBits" category="enum"/>
- <type name="VkImageCreateFlagBits" category="enum"/>
- <type name="VkImageLayout" category="enum"/>
- <type name="VkImageTiling" category="enum"/>
- <type name="VkImageType" category="enum"/>
- <type name="VkImageUsageFlagBits" category="enum"/>
- <type name="VkImageViewCreateFlagBits" category="enum"/>
- <type name="VkImageViewType" category="enum"/>
- <type name="VkSharingMode" category="enum"/>
- <type name="VkIndexType" category="enum"/>
- <type name="VkLogicOp" category="enum"/>
- <type name="VkMemoryHeapFlagBits" category="enum"/>
- <type name="VkAccessFlagBits" category="enum"/>
- <type name="VkMemoryPropertyFlagBits" category="enum"/>
- <type name="VkPhysicalDeviceType" category="enum"/>
- <type name="VkPipelineBindPoint" category="enum"/>
- <type name="VkPipelineCreateFlagBits" category="enum"/>
- <type name="VkPrimitiveTopology" category="enum"/>
- <type name="VkQueryControlFlagBits" category="enum"/>
- <type name="VkQueryPipelineStatisticFlagBits" category="enum"/>
- <type name="VkQueryResultFlagBits" category="enum"/>
- <type name="VkQueryType" category="enum"/>
- <type name="VkQueueFlagBits" category="enum"/>
- <type name="VkSubpassContents" category="enum"/>
- <type name="VkResult" category="enum"/>
- <type name="VkShaderStageFlagBits" category="enum"/>
- <type name="VkSparseMemoryBindFlagBits" category="enum"/>
- <type name="VkStencilFaceFlagBits" category="enum"/>
- <type name="VkStencilOp" category="enum"/>
- <type name="VkStructureType" category="enum"/>
- <type name="VkSystemAllocationScope" category="enum"/>
- <type name="VkInternalAllocationType" category="enum"/>
- <type name="VkSamplerAddressMode" category="enum"/>
- <type name="VkFilter" category="enum"/>
- <type name="VkSamplerMipmapMode" category="enum"/>
- <type name="VkVertexInputRate" category="enum"/>
- <type name="VkPipelineStageFlagBits" category="enum"/>
- <type name="VkSparseImageFormatFlagBits" category="enum"/>
- <type name="VkSampleCountFlagBits" category="enum"/>
- <type name="VkAttachmentDescriptionFlagBits" category="enum"/>
- <type name="VkDescriptorPoolCreateFlagBits" category="enum"/>
- <type name="VkDependencyFlagBits" category="enum"/>
- <type name="VkObjectType" category="enum"/>
- <type name="VkEventCreateFlagBits" category="enum"/>
- <type name="VkPipelineLayoutCreateFlagBits" category="enum"/>
- <type name="VkSemaphoreCreateFlagBits" category="enum"/>
-
- <comment>Extensions</comment>
- <type name="VkIndirectCommandsLayoutUsageFlagBitsNV" category="enum"/>
- <type name="VkIndirectCommandsTokenTypeNV" category="enum"/>
- <type name="VkIndirectStateFlagBitsNV" category="enum"/>
- <type name="VkPrivateDataSlotCreateFlagBitsEXT" category="enum"/>
- <type name="VkDescriptorUpdateTemplateType" category="enum"/>
- <type category="enum" name="VkDescriptorUpdateTemplateTypeKHR" alias="VkDescriptorUpdateTemplateType"/>
- <type name="VkViewportCoordinateSwizzleNV" category="enum"/>
- <type name="VkDiscardRectangleModeEXT" category="enum"/>
- <type name="VkSubpassDescriptionFlagBits" category="enum"/>
- <type name="VkPointClippingBehavior" category="enum"/>
- <type category="enum" name="VkPointClippingBehaviorKHR" alias="VkPointClippingBehavior"/>
- <type name="VkCoverageModulationModeNV" category="enum"/>
- <type name="VkCoverageReductionModeNV" category="enum"/>
- <type name="VkValidationCacheHeaderVersionEXT" category="enum"/>
- <type name="VkShaderInfoTypeAMD" category="enum"/>
- <type name="VkQueueGlobalPriorityEXT" category="enum"/>
- <type name="VkTimeDomainEXT" category="enum"/>
- <type name="VkConservativeRasterizationModeEXT" category="enum"/>
- <type name="VkResolveModeFlagBits" category="enum"/>
- <type category="enum" name="VkResolveModeFlagBitsKHR" alias="VkResolveModeFlagBits"/>
- <type name="VkDescriptorBindingFlagBits" category="enum"/>
- <type category="enum" name="VkDescriptorBindingFlagBitsEXT" alias="VkDescriptorBindingFlagBits"/>
- <type name="VkConditionalRenderingFlagBitsEXT" category="enum"/>
- <type name="VkSemaphoreType" category="enum"/>
- <type category="enum" name="VkSemaphoreTypeKHR" alias="VkSemaphoreType"/>
- <type name="VkGeometryFlagBitsKHR" category="enum"/>
- <type category="enum" name="VkGeometryFlagBitsNV" alias="VkGeometryFlagBitsKHR"/>
- <type name="VkGeometryInstanceFlagBitsKHR" category="enum"/>
- <type category="enum" name="VkGeometryInstanceFlagBitsNV" alias="VkGeometryInstanceFlagBitsKHR"/>
- <type name="VkBuildAccelerationStructureFlagBitsKHR" category="enum"/>
- <type category="enum" name="VkBuildAccelerationStructureFlagBitsNV" alias="VkBuildAccelerationStructureFlagBitsKHR"/>
- <type name="VkAccelerationStructureCreateFlagBitsKHR" category="enum"/>
- <type name="VkBuildAccelerationStructureModeKHR" category="enum"/>
- <type name="VkCopyAccelerationStructureModeKHR" category="enum"/>
- <type category="enum" name="VkCopyAccelerationStructureModeNV" alias="VkCopyAccelerationStructureModeKHR"/>
- <type name="VkAccelerationStructureTypeKHR" category="enum"/>
- <type category="enum" name="VkAccelerationStructureTypeNV" alias="VkAccelerationStructureTypeKHR"/>
- <type name="VkGeometryTypeKHR" category="enum"/>
- <type category="enum" name="VkGeometryTypeNV" alias="VkGeometryTypeKHR"/>
- <type name="VkRayTracingShaderGroupTypeKHR" category="enum"/>
- <type category="enum" name="VkRayTracingShaderGroupTypeNV" alias="VkRayTracingShaderGroupTypeKHR"/>
- <type name="VkAccelerationStructureMemoryRequirementsTypeNV" category="enum"/>
- <type name="VkAccelerationStructureBuildTypeKHR" category="enum"/>
- <type name="VkAccelerationStructureCompatibilityKHR" category="enum"/>
- <type name="VkShaderGroupShaderKHR" category="enum"/>
- <type name="VkMemoryOverallocationBehaviorAMD" category="enum"/>
- <type name="VkScopeNV" category="enum"/>
- <type name="VkComponentTypeNV" category="enum"/>
- <type name="VkDeviceDiagnosticsConfigFlagBitsNV" category="enum"/>
- <type name="VkPipelineCreationFeedbackFlagBitsEXT" category="enum"/>
- <type name="VkPerformanceCounterScopeKHR" category="enum"/>
- <type name="VkPerformanceCounterUnitKHR" category="enum"/>
- <type name="VkPerformanceCounterStorageKHR" category="enum"/>
- <type name="VkPerformanceCounterDescriptionFlagBitsKHR" category="enum"/>
- <type name="VkAcquireProfilingLockFlagBitsKHR" category="enum"/>
- <type name="VkSemaphoreWaitFlagBits" category="enum"/>
- <type category="enum" name="VkSemaphoreWaitFlagBitsKHR" alias="VkSemaphoreWaitFlagBits"/>
- <type name="VkPerformanceConfigurationTypeINTEL" category="enum"/>
- <type name="VkQueryPoolSamplingModeINTEL" category="enum"/>
- <type name="VkPerformanceOverrideTypeINTEL" category="enum"/>
- <type name="VkPerformanceParameterTypeINTEL" category="enum"/>
- <type name="VkPerformanceValueTypeINTEL" category="enum"/>
- <type name="VkLineRasterizationModeEXT" category="enum"/>
- <type name="VkShaderModuleCreateFlagBits" category="enum"/>
- <type name="VkPipelineCompilerControlFlagBitsAMD" category="enum"/>
- <type name="VkShaderCorePropertiesFlagBitsAMD" category="enum"/>
- <type name="VkToolPurposeFlagBitsEXT" category="enum"/>
- <type name="VkFragmentShadingRateNV" category="enum"/>
- <type name="VkFragmentShadingRateTypeNV" category="enum"/>
- <type name="VkAccessFlagBits2KHR" category="enum"/>
- <type name="VkPipelineStageFlagBits2KHR" category="enum"/>
- <type name="VkProvokingVertexModeEXT" category="enum"/>
- <type name="VkImageFormatConstraintsFlagBitsFUCHSIA" category="enum"/>
- <type name="VkImageConstraintsInfoFlagBitsFUCHSIA" category="enum"/>
- <type name="VkFormatFeatureFlagBits2KHR" category="enum"/>
- <type name="VkRenderingFlagBitsKHR" category="enum"/>
-
- <comment>WSI extensions</comment>
- <type name="VkColorSpaceKHR" category="enum"/>
- <type name="VkCompositeAlphaFlagBitsKHR" category="enum"/>
- <type name="VkDisplayPlaneAlphaFlagBitsKHR" category="enum"/>
- <type name="VkPresentModeKHR" category="enum"/>
- <type name="VkSurfaceTransformFlagBitsKHR" category="enum"/>
- <type name="VkDebugReportFlagBitsEXT" category="enum"/>
- <type name="VkDebugReportObjectTypeEXT" category="enum"/>
- <type name="VkDeviceMemoryReportEventTypeEXT" category="enum"/>
- <type name="VkRasterizationOrderAMD" category="enum"/>
- <type name="VkExternalMemoryHandleTypeFlagBitsNV" category="enum"/>
- <type name="VkExternalMemoryFeatureFlagBitsNV" category="enum"/>
- <type name="VkValidationCheckEXT" category="enum"/>
- <type name="VkValidationFeatureEnableEXT" category="enum"/>
- <type name="VkValidationFeatureDisableEXT" category="enum"/>
- <type name="VkExternalMemoryHandleTypeFlagBits" category="enum"/>
- <type category="enum" name="VkExternalMemoryHandleTypeFlagBitsKHR" alias="VkExternalMemoryHandleTypeFlagBits"/>
- <type name="VkExternalMemoryFeatureFlagBits" category="enum"/>
- <type category="enum" name="VkExternalMemoryFeatureFlagBitsKHR" alias="VkExternalMemoryFeatureFlagBits"/>
- <type name="VkExternalSemaphoreHandleTypeFlagBits" category="enum"/>
- <type category="enum" name="VkExternalSemaphoreHandleTypeFlagBitsKHR" alias="VkExternalSemaphoreHandleTypeFlagBits"/>
- <type name="VkExternalSemaphoreFeatureFlagBits" category="enum"/>
- <type category="enum" name="VkExternalSemaphoreFeatureFlagBitsKHR" alias="VkExternalSemaphoreFeatureFlagBits"/>
- <type name="VkSemaphoreImportFlagBits" category="enum"/>
- <type category="enum" name="VkSemaphoreImportFlagBitsKHR" alias="VkSemaphoreImportFlagBits"/>
- <type name="VkExternalFenceHandleTypeFlagBits" category="enum"/>
- <type category="enum" name="VkExternalFenceHandleTypeFlagBitsKHR" alias="VkExternalFenceHandleTypeFlagBits"/>
- <type name="VkExternalFenceFeatureFlagBits" category="enum"/>
- <type category="enum" name="VkExternalFenceFeatureFlagBitsKHR" alias="VkExternalFenceFeatureFlagBits"/>
- <type name="VkFenceImportFlagBits" category="enum"/>
- <type category="enum" name="VkFenceImportFlagBitsKHR" alias="VkFenceImportFlagBits"/>
- <type name="VkSurfaceCounterFlagBitsEXT" category="enum"/>
- <type name="VkDisplayPowerStateEXT" category="enum"/>
- <type name="VkDeviceEventTypeEXT" category="enum"/>
- <type name="VkDisplayEventTypeEXT" category="enum"/>
- <type name="VkPeerMemoryFeatureFlagBits" category="enum"/>
- <type category="enum" name="VkPeerMemoryFeatureFlagBitsKHR" alias="VkPeerMemoryFeatureFlagBits"/>
- <type name="VkMemoryAllocateFlagBits" category="enum"/>
- <type category="enum" name="VkMemoryAllocateFlagBitsKHR" alias="VkMemoryAllocateFlagBits"/>
- <type name="VkDeviceGroupPresentModeFlagBitsKHR" category="enum"/>
- <type name="VkSwapchainCreateFlagBitsKHR" category="enum"/>
- <type name="VkSubgroupFeatureFlagBits" category="enum"/>
- <type name="VkTessellationDomainOrigin" category="enum"/>
- <type category="enum" name="VkTessellationDomainOriginKHR" alias="VkTessellationDomainOrigin"/>
- <type name="VkSamplerYcbcrModelConversion" category="enum"/>
- <type category="enum" name="VkSamplerYcbcrModelConversionKHR" alias="VkSamplerYcbcrModelConversion"/>
- <type name="VkSamplerYcbcrRange" category="enum"/>
- <type category="enum" name="VkSamplerYcbcrRangeKHR" alias="VkSamplerYcbcrRange"/>
- <type name="VkChromaLocation" category="enum"/>
- <type category="enum" name="VkChromaLocationKHR" alias="VkChromaLocation"/>
- <type name="VkSamplerReductionMode" category="enum"/>
- <type category="enum" name="VkSamplerReductionModeEXT" alias="VkSamplerReductionMode"/>
- <type name="VkBlendOverlapEXT" category="enum"/>
- <type name="VkDebugUtilsMessageSeverityFlagBitsEXT" category="enum"/>
- <type name="VkDebugUtilsMessageTypeFlagBitsEXT" category="enum"/>
- <type name="VkFullScreenExclusiveEXT" category="enum"/>
- <type name="VkShaderFloatControlsIndependence" category="enum"/>
- <type category="enum" name="VkShaderFloatControlsIndependenceKHR" alias="VkShaderFloatControlsIndependence"/>
- <type name="VkFragmentShadingRateCombinerOpKHR" category="enum"/>
- <type name="VkSubmitFlagBitsKHR" category="enum"/>
-
- <comment>Enumerated types in the header, but not used by the API</comment>
- <type name="VkVendorId" category="enum"/>
- <type name="VkDriverId" category="enum"/>
- <type category="enum" name="VkDriverIdKHR" alias="VkDriverId"/>
- <type name="VkShadingRatePaletteEntryNV" category="enum"/>
- <type name="VkCoarseSampleOrderTypeNV" category="enum"/>
- <type name="VkPipelineExecutableStatisticFormatKHR" category="enum"/>
-
- <comment>Video Core extensions</comment>
- <type name="VkVideoCodecOperationFlagBitsKHR" category="enum"/>
- <type name="VkVideoChromaSubsamplingFlagBitsKHR" category="enum"/>
- <type name="VkVideoComponentBitDepthFlagBitsKHR" category="enum"/>
- <type name="VkVideoCapabilityFlagBitsKHR" category="enum"/>
- <type name="VkVideoSessionCreateFlagBitsKHR" category="enum"/>
- <type name="VkVideoCodingQualityPresetFlagBitsKHR" category="enum"/>
- <type name="VkVideoCodingControlFlagBitsKHR" category="enum"/>
- <type name="VkQueryResultStatusKHR" category="enum"/>
-
- <comment>Video Decode extensions</comment>
- <type name="VkVideoDecodeFlagBitsKHR" category="enum"/>
-
- <comment>Video H.264 Decode extensions</comment>
- <type name="VkVideoDecodeH264PictureLayoutFlagBitsEXT" category="enum"/>
-
- <comment>Video H.265 Decode extensions</comment>
-
- <comment>Video Encode extensions</comment>
- <type name="VkVideoEncodeFlagBitsKHR" category="enum"/>
- <type name="VkVideoEncodeRateControlFlagBitsKHR" category="enum"/>
- <type name="VkVideoEncodeRateControlModeFlagBitsKHR" category="enum"/>
-
- <comment>Video H.264 Encode extensions</comment>
- <type name="VkVideoEncodeH264CapabilityFlagBitsEXT" category="enum"/>
- <type name="VkVideoEncodeH264InputModeFlagBitsEXT" category="enum"/>
- <type name="VkVideoEncodeH264OutputModeFlagBitsEXT" category="enum"/>
- <type name="VkVideoEncodeH264CreateFlagBitsEXT" category="enum"/>
-
- <comment>Video H.265 Encode extensions</comment>
- <type name="VkVideoEncodeH265InputModeFlagBitsEXT" category="enum"/>
- <type name="VkVideoEncodeH265OutputModeFlagBitsEXT" category="enum"/>
- <type name="VkVideoEncodeH265CtbSizeFlagBitsEXT" category="enum"/>
-
- <comment>The PFN_vk*Function types are used by VkAllocationCallbacks below</comment>
- <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkInternalAllocationNotification</name>)(
- <type>void</type>* pUserData,
- <type>size_t</type> size,
- <type>VkInternalAllocationType</type> allocationType,
- <type>VkSystemAllocationScope</type> allocationScope);</type>
- <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkInternalFreeNotification</name>)(
- <type>void</type>* pUserData,
- <type>size_t</type> size,
- <type>VkInternalAllocationType</type> allocationType,
- <type>VkSystemAllocationScope</type> allocationScope);</type>
- <type category="funcpointer">typedef void* (VKAPI_PTR *<name>PFN_vkReallocationFunction</name>)(
- <type>void</type>* pUserData,
- <type>void</type>* pOriginal,
- <type>size_t</type> size,
- <type>size_t</type> alignment,
- <type>VkSystemAllocationScope</type> allocationScope);</type>
- <type category="funcpointer">typedef void* (VKAPI_PTR *<name>PFN_vkAllocationFunction</name>)(
- <type>void</type>* pUserData,
- <type>size_t</type> size,
- <type>size_t</type> alignment,
- <type>VkSystemAllocationScope</type> allocationScope);</type>
- <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkFreeFunction</name>)(
- <type>void</type>* pUserData,
- <type>void</type>* pMemory);</type>
-
- <comment>The PFN_vkVoidFunction type are used by VkGet*ProcAddr below</comment>
- <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkVoidFunction</name>)(void);</type>
-
- <comment>The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension</comment>
- <type category="funcpointer">typedef VkBool32 (VKAPI_PTR *<name>PFN_vkDebugReportCallbackEXT</name>)(
- <type>VkDebugReportFlagsEXT</type> flags,
- <type>VkDebugReportObjectTypeEXT</type> objectType,
- <type>uint64_t</type> object,
- <type>size_t</type> location,
- <type>int32_t</type> messageCode,
- const <type>char</type>* pLayerPrefix,
- const <type>char</type>* pMessage,
- <type>void</type>* pUserData);</type>
-
- <comment>The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension</comment>
- <type category="funcpointer" requires="VkDebugUtilsMessengerCallbackDataEXT">typedef VkBool32 (VKAPI_PTR *<name>PFN_vkDebugUtilsMessengerCallbackEXT</name>)(
- <type>VkDebugUtilsMessageSeverityFlagBitsEXT</type> messageSeverity,
- <type>VkDebugUtilsMessageTypeFlagsEXT</type> messageTypes,
- const <type>VkDebugUtilsMessengerCallbackDataEXT</type>* pCallbackData,
- <type>void</type>* pUserData);</type>
-
- <comment>The PFN_vkDeviceMemoryReportCallbackEXT type is used by the VK_EXT_device_memory_report extension</comment>
- <type category="funcpointer" requires="VkDeviceMemoryReportCallbackDataEXT">typedef void (VKAPI_PTR *<name>PFN_vkDeviceMemoryReportCallbackEXT</name>)(
- const <type>VkDeviceMemoryReportCallbackDataEXT</type>* pCallbackData,
- <type>void</type>* pUserData);</type>
-
- <comment>Struct types</comment>
- <type category="struct" name="VkBaseOutStructure">
- <member><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">struct <type>VkBaseOutStructure</type>* <name>pNext</name></member>
- </type>
- <type category="struct" name="VkBaseInStructure">
- <member><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const struct <type>VkBaseInStructure</type>* <name>pNext</name></member>
- </type>
- <type category="struct" name="VkOffset2D">
- <member><type>int32_t</type> <name>x</name></member>
- <member><type>int32_t</type> <name>y</name></member>
- </type>
- <type category="struct" name="VkOffset3D">
- <member><type>int32_t</type> <name>x</name></member>
- <member><type>int32_t</type> <name>y</name></member>
- <member><type>int32_t</type> <name>z</name></member>
- </type>
- <type category="struct" name="VkExtent2D">
- <member><type>uint32_t</type> <name>width</name></member>
- <member><type>uint32_t</type> <name>height</name></member>
- </type>
- <type category="struct" name="VkExtent3D">
- <member><type>uint32_t</type> <name>width</name></member>
- <member><type>uint32_t</type> <name>height</name></member>
- <member><type>uint32_t</type> <name>depth</name></member>
- </type>
- <type category="struct" name="VkViewport">
- <member noautovalidity="true"><type>float</type> <name>x</name></member>
- <member noautovalidity="true"><type>float</type> <name>y</name></member>
- <member noautovalidity="true"><type>float</type> <name>width</name></member>
- <member noautovalidity="true"><type>float</type> <name>height</name></member>
- <member><type>float</type> <name>minDepth</name></member>
- <member><type>float</type> <name>maxDepth</name></member>
- </type>
- <type category="struct" name="VkRect2D">
- <member><type>VkOffset2D</type> <name>offset</name></member>
- <member><type>VkExtent2D</type> <name>extent</name></member>
- </type>
- <type category="struct" name="VkClearRect">
- <member><type>VkRect2D</type> <name>rect</name></member>
- <member><type>uint32_t</type> <name>baseArrayLayer</name></member>
- <member><type>uint32_t</type> <name>layerCount</name></member>
- </type>
- <type category="struct" name="VkComponentMapping">
- <member><type>VkComponentSwizzle</type> <name>r</name></member>
- <member><type>VkComponentSwizzle</type> <name>g</name></member>
- <member><type>VkComponentSwizzle</type> <name>b</name></member>
- <member><type>VkComponentSwizzle</type> <name>a</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceProperties" returnedonly="true">
- <member limittype="noauto"><type>uint32_t</type> <name>apiVersion</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>driverVersion</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>vendorID</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>deviceID</name></member>
- <member limittype="noauto"><type>VkPhysicalDeviceType</type> <name>deviceType</name></member>
- <member limittype="noauto"><type>char</type> <name>deviceName</name>[<enum>VK_MAX_PHYSICAL_DEVICE_NAME_SIZE</enum>]</member>
- <member limittype="noauto"><type>uint8_t</type> <name>pipelineCacheUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
- <member limittype="struct"><type>VkPhysicalDeviceLimits</type> <name>limits</name></member>
- <member limittype="struct"><type>VkPhysicalDeviceSparseProperties</type> <name>sparseProperties</name></member>
- </type>
- <type category="struct" name="VkExtensionProperties" returnedonly="true">
- <member><type>char</type> <name>extensionName</name>[<enum>VK_MAX_EXTENSION_NAME_SIZE</enum>]<comment>extension name</comment></member>
- <member><type>uint32_t</type> <name>specVersion</name><comment>version of the extension specification implemented</comment></member>
- </type>
- <type category="struct" name="VkLayerProperties" returnedonly="true">
- <member><type>char</type> <name>layerName</name>[<enum>VK_MAX_EXTENSION_NAME_SIZE</enum>]<comment>layer name</comment></member>
- <member><type>uint32_t</type> <name>specVersion</name><comment>version of the layer specification implemented</comment></member>
- <member><type>uint32_t</type> <name>implementationVersion</name><comment>build or release version of the layer's library</comment></member>
- <member><type>char</type> <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]<comment>Free-form description of the layer</comment></member>
- </type>
- <type category="struct" name="VkApplicationInfo">
- <member values="VK_STRUCTURE_TYPE_APPLICATION_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true" len="null-terminated">const <type>char</type>* <name>pApplicationName</name></member>
- <member><type>uint32_t</type> <name>applicationVersion</name></member>
- <member optional="true" len="null-terminated">const <type>char</type>* <name>pEngineName</name></member>
- <member><type>uint32_t</type> <name>engineVersion</name></member>
- <member><type>uint32_t</type> <name>apiVersion</name></member>
- </type>
- <type category="struct" name="VkAllocationCallbacks">
- <member optional="true"><type>void</type>* <name>pUserData</name></member>
- <member noautovalidity="true"><type>PFN_vkAllocationFunction</type> <name>pfnAllocation</name></member>
- <member noautovalidity="true"><type>PFN_vkReallocationFunction</type> <name>pfnReallocation</name></member>
- <member noautovalidity="true"><type>PFN_vkFreeFunction</type> <name>pfnFree</name></member>
- <member optional="true" noautovalidity="true"><type>PFN_vkInternalAllocationNotification</type> <name>pfnInternalAllocation</name></member>
- <member optional="true" noautovalidity="true"><type>PFN_vkInternalFreeNotification</type> <name>pfnInternalFree</name></member>
- </type>
- <type category="struct" name="VkDeviceQueueCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDeviceQueueCreateFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>queueFamilyIndex</name></member>
- <member><type>uint32_t</type> <name>queueCount</name></member>
- <member len="queueCount">const <type>float</type>* <name>pQueuePriorities</name></member>
- </type>
- <type category="struct" name="VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDeviceCreateFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>queueCreateInfoCount</name></member>
- <member len="queueCreateInfoCount">const <type>VkDeviceQueueCreateInfo</type>* <name>pQueueCreateInfos</name></member>
- <member optional="true"><type>uint32_t</type> <name>enabledLayerCount</name></member>
- <member len="enabledLayerCount,null-terminated">const <type>char</type>* const* <name>ppEnabledLayerNames</name><comment>Ordered list of layer names to be enabled</comment></member>
- <member optional="true"><type>uint32_t</type> <name>enabledExtensionCount</name></member>
- <member len="enabledExtensionCount,null-terminated">const <type>char</type>* const* <name>ppEnabledExtensionNames</name></member>
- <member optional="true">const <type>VkPhysicalDeviceFeatures</type>* <name>pEnabledFeatures</name></member>
- </type>
- <type category="struct" name="VkInstanceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkInstanceCreateFlags</type> <name>flags</name></member>
- <member optional="true">const <type>VkApplicationInfo</type>* <name>pApplicationInfo</name></member>
- <member optional="true"><type>uint32_t</type> <name>enabledLayerCount</name></member>
- <member len="enabledLayerCount,null-terminated">const <type>char</type>* const* <name>ppEnabledLayerNames</name><comment>Ordered list of layer names to be enabled</comment></member>
- <member optional="true"><type>uint32_t</type> <name>enabledExtensionCount</name></member>
- <member len="enabledExtensionCount,null-terminated">const <type>char</type>* const* <name>ppEnabledExtensionNames</name><comment>Extension names to be enabled</comment></member>
- </type>
- <type category="struct" name="VkQueueFamilyProperties" returnedonly="true">
- <member optional="true"><type>VkQueueFlags</type> <name>queueFlags</name><comment>Queue flags</comment></member>
- <member><type>uint32_t</type> <name>queueCount</name></member>
- <member><type>uint32_t</type> <name>timestampValidBits</name></member>
- <member><type>VkExtent3D</type> <name>minImageTransferGranularity</name><comment>Minimum alignment requirement for image transfers</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMemoryProperties" returnedonly="true">
- <member><type>uint32_t</type> <name>memoryTypeCount</name></member>
- <member><type>VkMemoryType</type> <name>memoryTypes</name>[<enum>VK_MAX_MEMORY_TYPES</enum>]</member>
- <member><type>uint32_t</type> <name>memoryHeapCount</name></member>
- <member><type>VkMemoryHeap</type> <name>memoryHeaps</name>[<enum>VK_MAX_MEMORY_HEAPS</enum>]</member>
- </type>
- <type category="struct" name="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceSize</type> <name>allocationSize</name><comment>Size of memory allocation</comment></member>
- <member devicememorytypeindex="1"><type>uint32_t</type> <name>memoryTypeIndex</name><comment>Index of the of the memory type to allocate from</comment></member>
- </type>
- <type category="struct" name="VkMemoryRequirements" returnedonly="true">
- <member><type>VkDeviceSize</type> <name>size</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>alignment</name><comment>Specified in bytes</comment></member>
- <member devicememorytypebits="1"><type>uint32_t</type> <name>memoryTypeBits</name><comment>Bitmask of the allowed memory type indices into memoryTypes[] for this object</comment></member>
- </type>
- <type category="struct" name="VkSparseImageFormatProperties" returnedonly="true">
- <member optional="true"><type>VkImageAspectFlags</type> <name>aspectMask</name></member>
- <member><type>VkExtent3D</type> <name>imageGranularity</name></member>
- <member optional="true"><type>VkSparseImageFormatFlags</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkSparseImageMemoryRequirements" returnedonly="true">
- <member><type>VkSparseImageFormatProperties</type> <name>formatProperties</name></member>
- <member><type>uint32_t</type> <name>imageMipTailFirstLod</name></member>
- <member><type>VkDeviceSize</type> <name>imageMipTailSize</name><comment>Specified in bytes, must be a multiple of sparse block size in bytes / alignment</comment></member>
- <member><type>VkDeviceSize</type> <name>imageMipTailOffset</name><comment>Specified in bytes, must be a multiple of sparse block size in bytes / alignment</comment></member>
- <member><type>VkDeviceSize</type> <name>imageMipTailStride</name><comment>Specified in bytes, must be a multiple of sparse block size in bytes / alignment</comment></member>
- </type>
- <type category="struct" name="VkMemoryType" returnedonly="true">
- <member optional="true"><type>VkMemoryPropertyFlags</type> <name>propertyFlags</name><comment>Memory properties of this memory type</comment></member>
- <member><type>uint32_t</type> <name>heapIndex</name><comment>Index of the memory heap allocations of this memory type are taken from</comment></member>
- </type>
- <type category="struct" name="VkMemoryHeap" returnedonly="true">
- <member><type>VkDeviceSize</type> <name>size</name><comment>Available memory in the heap</comment></member>
- <member optional="true"><type>VkMemoryHeapFlags</type> <name>flags</name><comment>Flags for the heap</comment></member>
- </type>
- <type category="struct" name="VkMappedMemoryRange">
- <member values="VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name><comment>Mapped memory object</comment></member>
- <member devicememoryoffset="1"><type>VkDeviceSize</type> <name>offset</name><comment>Offset within the memory object where the range starts</comment></member>
- <member devicememorysize="1"><type>VkDeviceSize</type> <name>size</name><comment>Size of the range within the memory object</comment></member>
- </type>
- <type category="struct" name="VkFormatProperties" returnedonly="true">
- <member optional="true"><type>VkFormatFeatureFlags</type> <name>linearTilingFeatures</name><comment>Format features in case of linear tiling</comment></member>
- <member optional="true"><type>VkFormatFeatureFlags</type> <name>optimalTilingFeatures</name><comment>Format features in case of optimal tiling</comment></member>
- <member optional="true"><type>VkFormatFeatureFlags</type> <name>bufferFeatures</name><comment>Format features supported by buffers</comment></member>
- </type>
- <type category="struct" name="VkImageFormatProperties" returnedonly="true">
- <member><type>VkExtent3D</type> <name>maxExtent</name><comment>max image dimensions for this resource type</comment></member>
- <member><type>uint32_t</type> <name>maxMipLevels</name><comment>max number of mipmap levels for this resource type</comment></member>
- <member><type>uint32_t</type> <name>maxArrayLayers</name><comment>max array size for this resource type</comment></member>
- <member optional="true"><type>VkSampleCountFlags</type> <name>sampleCounts</name><comment>supported sample counts for this resource type</comment></member>
- <member><type>VkDeviceSize</type> <name>maxResourceSize</name><comment>max size (in bytes) of this resource type</comment></member>
- </type>
- <type category="struct" name="VkDescriptorBufferInfo">
- <member optional="true"><type>VkBuffer</type> <name>buffer</name><comment>Buffer used for this descriptor slot.</comment></member>
- <member><type>VkDeviceSize</type> <name>offset</name><comment>Base offset from buffer start in bytes to update in the descriptor set.</comment></member>
- <member><type>VkDeviceSize</type> <name>range</name><comment>Size in bytes of the buffer resource for this descriptor update.</comment></member>
- </type>
- <type category="struct" name="VkDescriptorImageInfo">
- <member noautovalidity="true"><type>VkSampler</type> <name>sampler</name><comment>Sampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise.</comment></member>
- <member noautovalidity="true"><type>VkImageView</type> <name>imageView</name><comment>Image view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise.</comment></member>
- <member noautovalidity="true"><type>VkImageLayout</type> <name>imageLayout</name><comment>Layout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE).</comment></member>
- </type>
- <type category="struct" name="VkWriteDescriptorSet">
- <member values="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkDescriptorSet</type> <name>dstSet</name><comment>Destination descriptor set</comment></member>
- <member><type>uint32_t</type> <name>dstBinding</name><comment>Binding within the destination descriptor set to write</comment></member>
- <member><type>uint32_t</type> <name>dstArrayElement</name><comment>Array element within the destination binding to write</comment></member>
- <member><type>uint32_t</type> <name>descriptorCount</name><comment>Number of descriptors to write (determines the size of the array pointed by pDescriptors)</comment></member>
- <member><type>VkDescriptorType</type> <name>descriptorType</name><comment>Descriptor type to write (determines which members of the array pointed by pDescriptors are going to be used)</comment></member>
- <member noautovalidity="true" len="descriptorCount"
- filterVar="descriptorType"
- filterVals="VK_DESCRIPTOR_TYPE_SAMPLER,VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT"
- >const <type>VkDescriptorImageInfo</type>* <name>pImageInfo</name><comment>Sampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types.</comment></member>
- <member noautovalidity="true" len="descriptorCount"
- filterVar="descriptorType"
- filterVals="VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC"
- >const <type>VkDescriptorBufferInfo</type>* <name>pBufferInfo</name><comment>Raw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types.</comment></member>
- <member noautovalidity="true" len="descriptorCount"
- filterVar="descriptorType"
- filterVals="VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER">const <type>VkBufferView</type>* <name>pTexelBufferView</name><comment>Buffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types.</comment></member>
- </type>
- <type category="struct" name="VkCopyDescriptorSet">
- <member values="VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDescriptorSet</type> <name>srcSet</name><comment>Source descriptor set</comment></member>
- <member><type>uint32_t</type> <name>srcBinding</name><comment>Binding within the source descriptor set to copy from</comment></member>
- <member><type>uint32_t</type> <name>srcArrayElement</name><comment>Array element within the source binding to copy from</comment></member>
- <member><type>VkDescriptorSet</type> <name>dstSet</name><comment>Destination descriptor set</comment></member>
- <member><type>uint32_t</type> <name>dstBinding</name><comment>Binding within the destination descriptor set to copy to</comment></member>
- <member><type>uint32_t</type> <name>dstArrayElement</name><comment>Array element within the destination binding to copy to</comment></member>
- <member><type>uint32_t</type> <name>descriptorCount</name><comment>Number of descriptors to write (determines the size of the array pointed by pDescriptors)</comment></member>
- </type>
- <type category="struct" name="VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkBufferCreateFlags</type> <name>flags</name><comment>Buffer creation flags</comment></member>
- <member><type>VkDeviceSize</type> <name>size</name><comment>Specified in bytes</comment></member>
- <member><type>VkBufferUsageFlags</type> <name>usage</name><comment>Buffer usage flags</comment></member>
- <member><type>VkSharingMode</type> <name>sharingMode</name></member>
- <member optional="true"><type>uint32_t</type> <name>queueFamilyIndexCount</name></member>
- <member noautovalidity="true" len="queueFamilyIndexCount">const <type>uint32_t</type>* <name>pQueueFamilyIndices</name></member>
- </type>
- <type category="struct" name="VkBufferViewCreateInfo">
- <member values="VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkBufferViewCreateFlags</type><name>flags</name></member>
- <member><type>VkBuffer</type> <name>buffer</name></member>
- <member><type>VkFormat</type> <name>format</name><comment>Optionally specifies format of elements</comment></member>
- <member><type>VkDeviceSize</type> <name>offset</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>range</name><comment>View size specified in bytes</comment></member>
- </type>
- <type category="struct" name="VkImageSubresource">
- <member><type>VkImageAspectFlags</type> <name>aspectMask</name></member>
- <member><type>uint32_t</type> <name>mipLevel</name></member>
- <member><type>uint32_t</type> <name>arrayLayer</name></member>
- </type>
- <type category="struct" name="VkImageSubresourceLayers">
- <member><type>VkImageAspectFlags</type> <name>aspectMask</name></member>
- <member><type>uint32_t</type> <name>mipLevel</name></member>
- <member><type>uint32_t</type> <name>baseArrayLayer</name></member>
- <member><type>uint32_t</type> <name>layerCount</name></member>
- </type>
- <type category="struct" name="VkImageSubresourceRange">
- <member><type>VkImageAspectFlags</type> <name>aspectMask</name></member>
- <member><type>uint32_t</type> <name>baseMipLevel</name></member>
- <member><type>uint32_t</type> <name>levelCount</name></member>
- <member><type>uint32_t</type> <name>baseArrayLayer</name></member>
- <member><type>uint32_t</type> <name>layerCount</name></member>
- </type>
- <type category="struct" name="VkMemoryBarrier">
- <member values="VK_STRUCTURE_TYPE_MEMORY_BARRIER"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkAccessFlags</type> <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
- <member optional="true"><type>VkAccessFlags</type> <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
- </type>
- <type category="struct" name="VkBufferMemoryBarrier">
- <member values="VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkAccessFlags</type> <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
- <member noautovalidity="true"><type>VkAccessFlags</type> <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
- <member><type>uint32_t</type> <name>srcQueueFamilyIndex</name><comment>Queue family to transition ownership from</comment></member>
- <member><type>uint32_t</type> <name>dstQueueFamilyIndex</name><comment>Queue family to transition ownership to</comment></member>
- <member><type>VkBuffer</type> <name>buffer</name><comment>Buffer to sync</comment></member>
- <member><type>VkDeviceSize</type> <name>offset</name><comment>Offset within the buffer to sync</comment></member>
- <member><type>VkDeviceSize</type> <name>size</name><comment>Amount of bytes to sync</comment></member>
- </type>
- <type category="struct" name="VkImageMemoryBarrier">
- <member values="VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkAccessFlags</type> <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
- <member noautovalidity="true"><type>VkAccessFlags</type> <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
- <member><type>VkImageLayout</type> <name>oldLayout</name><comment>Current layout of the image</comment></member>
- <member><type>VkImageLayout</type> <name>newLayout</name><comment>New layout to transition the image to</comment></member>
- <member><type>uint32_t</type> <name>srcQueueFamilyIndex</name><comment>Queue family to transition ownership from</comment></member>
- <member><type>uint32_t</type> <name>dstQueueFamilyIndex</name><comment>Queue family to transition ownership to</comment></member>
- <member><type>VkImage</type> <name>image</name><comment>Image to sync</comment></member>
- <member><type>VkImageSubresourceRange</type> <name>subresourceRange</name><comment>Subresource range to sync</comment></member>
- </type>
- <type category="struct" name="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImageCreateFlags</type> <name>flags</name><comment>Image creation flags</comment></member>
- <member><type>VkImageType</type> <name>imageType</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkExtent3D</type> <name>extent</name></member>
- <member><type>uint32_t</type> <name>mipLevels</name></member>
- <member><type>uint32_t</type> <name>arrayLayers</name></member>
- <member><type>VkSampleCountFlagBits</type> <name>samples</name></member>
- <member><type>VkImageTiling</type> <name>tiling</name></member>
- <member><type>VkImageUsageFlags</type> <name>usage</name><comment>Image usage flags</comment></member>
- <member><type>VkSharingMode</type> <name>sharingMode</name><comment>Cross-queue-family sharing mode</comment></member>
- <member optional="true"><type>uint32_t</type> <name>queueFamilyIndexCount</name><comment>Number of queue families to share across</comment></member>
- <member noautovalidity="true" len="queueFamilyIndexCount">const <type>uint32_t</type>* <name>pQueueFamilyIndices</name><comment>Array of queue family indices to share across</comment></member>
- <member><type>VkImageLayout</type> <name>initialLayout</name><comment>Initial image layout for all subresources</comment></member>
- </type>
- <type category="struct" name="VkSubresourceLayout" returnedonly="true">
- <member><type>VkDeviceSize</type> <name>offset</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>size</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>rowPitch</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>arrayPitch</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>depthPitch</name><comment>Specified in bytes</comment></member>
- </type>
- <type category="struct" name="VkImageViewCreateInfo">
- <member values="VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImageViewCreateFlags</type> <name>flags</name></member>
- <member><type>VkImage</type> <name>image</name></member>
- <member><type>VkImageViewType</type> <name>viewType</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkComponentMapping</type> <name>components</name></member>
- <member><type>VkImageSubresourceRange</type> <name>subresourceRange</name></member>
- </type>
- <type category="struct" name="VkBufferCopy">
- <member><type>VkDeviceSize</type> <name>srcOffset</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>dstOffset</name><comment>Specified in bytes</comment></member>
- <member noautovalidity="true"><type>VkDeviceSize</type> <name>size</name><comment>Specified in bytes</comment></member>
- </type>
- <type category="struct" name="VkSparseMemoryBind">
- <member><type>VkDeviceSize</type> <name>resourceOffset</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>size</name><comment>Specified in bytes</comment></member>
- <member optional="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- <member devicememoryoffset="1"><type>VkDeviceSize</type> <name>memoryOffset</name><comment>Specified in bytes</comment></member>
- <member optional="true"><type>VkSparseMemoryBindFlags</type><name>flags</name></member>
- </type>
- <type category="struct" name="VkSparseImageMemoryBind">
- <member><type>VkImageSubresource</type> <name>subresource</name></member>
- <member><type>VkOffset3D</type> <name>offset</name></member>
- <member><type>VkExtent3D</type> <name>extent</name></member>
- <member optional="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- <member devicememoryoffset="1"><type>VkDeviceSize</type> <name>memoryOffset</name><comment>Specified in bytes</comment></member>
- <member optional="true"><type>VkSparseMemoryBindFlags</type><name>flags</name></member>
- </type>
- <type category="struct" name="VkSparseBufferMemoryBindInfo">
- <member><type>VkBuffer</type> <name>buffer</name></member>
- <member><type>uint32_t</type> <name>bindCount</name></member>
- <member len="bindCount">const <type>VkSparseMemoryBind</type>* <name>pBinds</name></member>
- </type>
- <type category="struct" name="VkSparseImageOpaqueMemoryBindInfo">
- <member><type>VkImage</type> <name>image</name></member>
- <member><type>uint32_t</type> <name>bindCount</name></member>
- <member len="bindCount">const <type>VkSparseMemoryBind</type>* <name>pBinds</name></member>
- </type>
- <type category="struct" name="VkSparseImageMemoryBindInfo">
- <member><type>VkImage</type> <name>image</name></member>
- <member><type>uint32_t</type> <name>bindCount</name></member>
- <member len="bindCount">const <type>VkSparseImageMemoryBind</type>* <name>pBinds</name></member>
- </type>
- <type category="struct" name="VkBindSparseInfo">
- <member values="VK_STRUCTURE_TYPE_BIND_SPARSE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></member>
- <member len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></member>
- <member optional="true"><type>uint32_t</type> <name>bufferBindCount</name></member>
- <member len="bufferBindCount">const <type>VkSparseBufferMemoryBindInfo</type>* <name>pBufferBinds</name></member>
- <member optional="true"><type>uint32_t</type> <name>imageOpaqueBindCount</name></member>
- <member len="imageOpaqueBindCount">const <type>VkSparseImageOpaqueMemoryBindInfo</type>* <name>pImageOpaqueBinds</name></member>
- <member optional="true"><type>uint32_t</type> <name>imageBindCount</name></member>
- <member len="imageBindCount">const <type>VkSparseImageMemoryBindInfo</type>* <name>pImageBinds</name></member>
- <member optional="true"><type>uint32_t</type> <name>signalSemaphoreCount</name></member>
- <member len="signalSemaphoreCount">const <type>VkSemaphore</type>* <name>pSignalSemaphores</name></member>
- </type>
- <type category="struct" name="VkImageCopy">
- <member><type>VkImageSubresourceLayers</type> <name>srcSubresource</name></member>
- <member><type>VkOffset3D</type> <name>srcOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkImageSubresourceLayers</type> <name>dstSubresource</name></member>
- <member><type>VkOffset3D</type> <name>dstOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkExtent3D</type> <name>extent</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- </type>
- <type category="struct" name="VkImageBlit">
- <member><type>VkImageSubresourceLayers</type> <name>srcSubresource</name></member>
- <member><type>VkOffset3D</type> <name>srcOffsets</name>[2]<comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkImageSubresourceLayers</type> <name>dstSubresource</name></member>
- <member><type>VkOffset3D</type> <name>dstOffsets</name>[2]<comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- </type>
- <type category="struct" name="VkBufferImageCopy">
- <member><type>VkDeviceSize</type> <name>bufferOffset</name><comment>Specified in bytes</comment></member>
- <member><type>uint32_t</type> <name>bufferRowLength</name><comment>Specified in texels</comment></member>
- <member><type>uint32_t</type> <name>bufferImageHeight</name></member>
- <member><type>VkImageSubresourceLayers</type> <name>imageSubresource</name></member>
- <member><type>VkOffset3D</type> <name>imageOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkExtent3D</type> <name>imageExtent</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- </type>
- <type category="struct" name="VkImageResolve">
- <member><type>VkImageSubresourceLayers</type> <name>srcSubresource</name></member>
- <member><type>VkOffset3D</type> <name>srcOffset</name></member>
- <member><type>VkImageSubresourceLayers</type> <name>dstSubresource</name></member>
- <member><type>VkOffset3D</type> <name>dstOffset</name></member>
- <member><type>VkExtent3D</type> <name>extent</name></member>
- </type>
- <type category="struct" name="VkShaderModuleCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkShaderModuleCreateFlags</type> <name>flags</name></member>
- <member><type>size_t</type> <name>codeSize</name><comment>Specified in bytes</comment></member>
- <member len="latexmath:[\textrm{codeSize} \over 4]" altlen="codeSize / 4">const <type>uint32_t</type>* <name>pCode</name><comment>Binary code of size codeSize</comment></member>
- </type>
- <type category="struct" name="VkDescriptorSetLayoutBinding">
- <member><type>uint32_t</type> <name>binding</name><comment>Binding number for this entry</comment></member>
- <member><type>VkDescriptorType</type> <name>descriptorType</name><comment>Type of the descriptors in this binding</comment></member>
- <member optional="true"><type>uint32_t</type> <name>descriptorCount</name><comment>Number of descriptors in this binding</comment></member>
- <member noautovalidity="true"><type>VkShaderStageFlags</type> <name>stageFlags</name><comment>Shader stages this binding is visible to</comment></member>
- <member noautovalidity="true" optional="true" len="descriptorCount">const <type>VkSampler</type>* <name>pImmutableSamplers</name><comment>Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements)</comment></member>
- </type>
- <type category="struct" name="VkDescriptorSetLayoutCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDescriptorSetLayoutCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>bindingCount</name><comment>Number of bindings in the descriptor set layout</comment></member>
- <member len="bindingCount">const <type>VkDescriptorSetLayoutBinding</type>* <name>pBindings</name><comment>Array of descriptor set layout bindings</comment></member>
- </type>
- <type category="struct" name="VkDescriptorPoolSize">
- <member><type>VkDescriptorType</type> <name>type</name></member>
- <member><type>uint32_t</type> <name>descriptorCount</name></member>
- </type>
- <type category="struct" name="VkDescriptorPoolCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDescriptorPoolCreateFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>maxSets</name></member>
- <member><type>uint32_t</type> <name>poolSizeCount</name></member>
- <member len="poolSizeCount">const <type>VkDescriptorPoolSize</type>* <name>pPoolSizes</name></member>
- </type>
- <type category="struct" name="VkDescriptorSetAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDescriptorPool</type> <name>descriptorPool</name></member>
- <member><type>uint32_t</type> <name>descriptorSetCount</name></member>
- <member len="descriptorSetCount">const <type>VkDescriptorSetLayout</type>* <name>pSetLayouts</name></member>
- </type>
- <type category="struct" name="VkSpecializationMapEntry">
- <member><type>uint32_t</type> <name>constantID</name><comment>The SpecConstant ID specified in the BIL</comment></member>
- <member><type>uint32_t</type> <name>offset</name><comment>Offset of the value in the data block</comment></member>
- <member noautovalidity="true"><type>size_t</type> <name>size</name><comment>Size in bytes of the SpecConstant</comment></member>
- </type>
- <type category="struct" name="VkSpecializationInfo">
- <member optional="true"><type>uint32_t</type> <name>mapEntryCount</name><comment>Number of entries in the map</comment></member>
- <member len="mapEntryCount">const <type>VkSpecializationMapEntry</type>* <name>pMapEntries</name><comment>Array of map entries</comment></member>
- <member optional="true"><type>size_t</type> <name>dataSize</name><comment>Size in bytes of pData</comment></member>
- <member len="dataSize">const <type>void</type>* <name>pData</name><comment>Pointer to SpecConstant data</comment></member>
- </type>
- <type category="struct" name="VkPipelineShaderStageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineShaderStageCreateFlags</type> <name>flags</name></member>
- <member><type>VkShaderStageFlagBits</type> <name>stage</name><comment>Shader stage</comment></member>
- <member><type>VkShaderModule</type> <name>module</name><comment>Module containing entry point</comment></member>
- <member len="null-terminated">const <type>char</type>* <name>pName</name><comment>Null-terminated entry point name</comment></member>
- <member optional="true">const <type>VkSpecializationInfo</type>* <name>pSpecializationInfo</name></member>
- </type>
- <type category="struct" name="VkComputePipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCreateFlags</type> <name>flags</name><comment>Pipeline creation flags</comment></member>
- <member><type>VkPipelineShaderStageCreateInfo</type> <name>stage</name></member>
- <member><type>VkPipelineLayout</type> <name>layout</name><comment>Interface layout of the pipeline</comment></member>
- <member noautovalidity="true" optional="true"><type>VkPipeline</type> <name>basePipelineHandle</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of</comment></member>
- <member><type>int32_t</type> <name>basePipelineIndex</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of</comment></member>
- </type>
- <type category="struct" name="VkVertexInputBindingDescription">
- <member><type>uint32_t</type> <name>binding</name><comment>Vertex buffer binding id</comment></member>
- <member><type>uint32_t</type> <name>stride</name><comment>Distance between vertices in bytes (0 = no advancement)</comment></member>
- <member><type>VkVertexInputRate</type> <name>inputRate</name><comment>The rate at which the vertex data is consumed</comment></member>
- </type>
- <type category="struct" name="VkVertexInputAttributeDescription">
- <member><type>uint32_t</type> <name>location</name><comment>location of the shader vertex attrib</comment></member>
- <member><type>uint32_t</type> <name>binding</name><comment>Vertex buffer binding id</comment></member>
- <member><type>VkFormat</type> <name>format</name><comment>format of source data</comment></member>
- <member><type>uint32_t</type> <name>offset</name><comment>Offset of first element in bytes from base of vertex</comment></member>
- </type>
- <type category="struct" name="VkPipelineVertexInputStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineVertexInputStateCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>vertexBindingDescriptionCount</name><comment>number of bindings</comment></member>
- <member len="vertexBindingDescriptionCount">const <type>VkVertexInputBindingDescription</type>* <name>pVertexBindingDescriptions</name></member>
- <member optional="true"><type>uint32_t</type> <name>vertexAttributeDescriptionCount</name><comment>number of attributes</comment></member>
- <member len="vertexAttributeDescriptionCount">const <type>VkVertexInputAttributeDescription</type>* <name>pVertexAttributeDescriptions</name></member>
- </type>
- <type category="struct" name="VkPipelineInputAssemblyStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineInputAssemblyStateCreateFlags</type> <name>flags</name></member>
- <member><type>VkPrimitiveTopology</type> <name>topology</name></member>
- <member><type>VkBool32</type> <name>primitiveRestartEnable</name></member>
- </type>
- <type category="struct" name="VkPipelineTessellationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineTessellationStateCreateFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>patchControlPoints</name></member>
- </type>
- <type category="struct" name="VkPipelineViewportStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineViewportStateCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>viewportCount</name></member>
- <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewport</type>* <name>pViewports</name></member>
- <member optional="true"><type>uint32_t</type> <name>scissorCount</name></member>
- <member noautovalidity="true" optional="true" len="scissorCount">const <type>VkRect2D</type>* <name>pScissors</name></member>
- </type>
- <type category="struct" name="VkPipelineRasterizationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineRasterizationStateCreateFlags</type> <name>flags</name></member>
- <member><type>VkBool32</type> <name>depthClampEnable</name></member>
- <member><type>VkBool32</type> <name>rasterizerDiscardEnable</name></member>
- <member><type>VkPolygonMode</type> <name>polygonMode</name><comment>optional (GL45)</comment></member>
- <member optional="true"><type>VkCullModeFlags</type> <name>cullMode</name></member>
- <member><type>VkFrontFace</type> <name>frontFace</name></member>
- <member><type>VkBool32</type> <name>depthBiasEnable</name></member>
- <member><type>float</type> <name>depthBiasConstantFactor</name></member>
- <member><type>float</type> <name>depthBiasClamp</name></member>
- <member><type>float</type> <name>depthBiasSlopeFactor</name></member>
- <member><type>float</type> <name>lineWidth</name></member>
- </type>
- <type category="struct" name="VkPipelineMultisampleStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineMultisampleStateCreateFlags</type> <name>flags</name></member>
- <member><type>VkSampleCountFlagBits</type> <name>rasterizationSamples</name><comment>Number of samples used for rasterization</comment></member>
- <member><type>VkBool32</type> <name>sampleShadingEnable</name><comment>optional (GL45)</comment></member>
- <member><type>float</type> <name>minSampleShading</name><comment>optional (GL45)</comment></member>
- <member optional="true" len="latexmath:[\lceil{\mathit{rasterizationSamples} \over 32}\rceil]" altlen="(rasterizationSamples + 31) / 32">const <type>VkSampleMask</type>* <name>pSampleMask</name><comment>Array of sampleMask words</comment></member>
- <member><type>VkBool32</type> <name>alphaToCoverageEnable</name></member>
- <member><type>VkBool32</type> <name>alphaToOneEnable</name></member>
- </type>
- <type category="struct" name="VkPipelineColorBlendAttachmentState">
- <member><type>VkBool32</type> <name>blendEnable</name></member>
- <member><type>VkBlendFactor</type> <name>srcColorBlendFactor</name></member>
- <member><type>VkBlendFactor</type> <name>dstColorBlendFactor</name></member>
- <member><type>VkBlendOp</type> <name>colorBlendOp</name></member>
- <member><type>VkBlendFactor</type> <name>srcAlphaBlendFactor</name></member>
- <member><type>VkBlendFactor</type> <name>dstAlphaBlendFactor</name></member>
- <member><type>VkBlendOp</type> <name>alphaBlendOp</name></member>
- <member optional="true"><type>VkColorComponentFlags</type> <name>colorWriteMask</name></member>
- </type>
- <type category="struct" name="VkPipelineColorBlendStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineColorBlendStateCreateFlags</type> <name>flags</name></member>
- <member><type>VkBool32</type> <name>logicOpEnable</name></member>
- <member noautovalidity="true"><type>VkLogicOp</type> <name>logicOp</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentCount</name><comment># of pAttachments</comment></member>
- <member len="attachmentCount">const <type>VkPipelineColorBlendAttachmentState</type>* <name>pAttachments</name></member>
- <member><type>float</type> <name>blendConstants</name>[4]</member>
- </type>
- <type category="struct" name="VkPipelineDynamicStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineDynamicStateCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>dynamicStateCount</name></member>
- <member len="dynamicStateCount">const <type>VkDynamicState</type>* <name>pDynamicStates</name></member>
- </type>
- <type category="struct" name="VkStencilOpState">
- <member><type>VkStencilOp</type> <name>failOp</name></member>
- <member><type>VkStencilOp</type> <name>passOp</name></member>
- <member><type>VkStencilOp</type> <name>depthFailOp</name></member>
- <member><type>VkCompareOp</type> <name>compareOp</name></member>
- <member><type>uint32_t</type> <name>compareMask</name></member>
- <member><type>uint32_t</type> <name>writeMask</name></member>
- <member><type>uint32_t</type> <name>reference</name></member>
- </type>
- <type category="struct" name="VkPipelineDepthStencilStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineDepthStencilStateCreateFlags</type> <name>flags</name></member>
- <member><type>VkBool32</type> <name>depthTestEnable</name></member>
- <member><type>VkBool32</type> <name>depthWriteEnable</name></member>
- <member><type>VkCompareOp</type> <name>depthCompareOp</name></member>
- <member><type>VkBool32</type> <name>depthBoundsTestEnable</name><comment>optional (depth_bounds_test)</comment></member>
- <member><type>VkBool32</type> <name>stencilTestEnable</name></member>
- <member><type>VkStencilOpState</type> <name>front</name></member>
- <member><type>VkStencilOpState</type> <name>back</name></member>
- <member><type>float</type> <name>minDepthBounds</name></member>
- <member><type>float</type> <name>maxDepthBounds</name></member>
- </type>
- <type category="struct" name="VkGraphicsPipelineCreateInfo" let="hasTessellation : (arrayany pStages 0 stageCount (lambda ((s VkPipelineShaderStageCreateInfo)) (or (eq (getfield s stage) VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) (eq (getfield s stage) VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)))),hasRasterization : (if (eq 0 pRasterizationState) 0 (not (getfield pRasterizationState rasterizerDiscardEnable)))">
- <member values="VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCreateFlags</type> <name>flags</name><comment>Pipeline creation flags</comment></member>
- <member><type>uint32_t</type> <name>stageCount</name></member>
- <member len="stageCount">const <type>VkPipelineShaderStageCreateInfo</type>* <name>pStages</name><comment>One entry for each active shader stage</comment></member>
- <member noautovalidity="true" optional="streamFeature:VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT">const <type>VkPipelineVertexInputStateCreateInfo</type>* <name>pVertexInputState</name></member>
- <member noautovalidity="true" optional="streamFeature:VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT">const <type>VkPipelineInputAssemblyStateCreateInfo</type>* <name>pInputAssemblyState</name></member>
- <member noautovalidity="true" optional="true" filterVar="hasTessellation">const <type>VkPipelineTessellationStateCreateInfo</type>* <name>pTessellationState</name></member>
- <member noautovalidity="true" optional="true" filterVar="hasRasterization">const <type>VkPipelineViewportStateCreateInfo</type>* <name>pViewportState</name></member>
- <member noautovalidity="true" optional="streamFeature:VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT">const <type>VkPipelineRasterizationStateCreateInfo</type>* <name>pRasterizationState</name></member>
- <member noautovalidity="true" optional="true" filterVar="hasRasterization">const <type>VkPipelineMultisampleStateCreateInfo</type>* <name>pMultisampleState</name></member>
- <member noautovalidity="true" optional="true" filterVar="hasRasterization">const <type>VkPipelineDepthStencilStateCreateInfo</type>* <name>pDepthStencilState</name></member>
- <member noautovalidity="true" optional="true" filterVar="hasRasterization">const <type>VkPipelineColorBlendStateCreateInfo</type>* <name>pColorBlendState</name></member>
- <member optional="true">const <type>VkPipelineDynamicStateCreateInfo</type>* <name>pDynamicState</name></member>
- <member><type>VkPipelineLayout</type> <name>layout</name><comment>Interface layout of the pipeline</comment></member>
- <member optional="true"><type>VkRenderPass</type> <name>renderPass</name></member>
- <member><type>uint32_t</type> <name>subpass</name></member>
- <member noautovalidity="true" optional="true"><type>VkPipeline</type> <name>basePipelineHandle</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of</comment></member>
- <member><type>int32_t</type> <name>basePipelineIndex</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of</comment></member>
- </type>
- <type category="struct" name="VkPipelineCacheCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCacheCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>size_t</type> <name>initialDataSize</name><comment>Size of initial data to populate cache, in bytes</comment></member>
- <member len="initialDataSize">const <type>void</type>* <name>pInitialData</name><comment>Initial data to populate cache</comment></member>
- </type>
- <type category="struct" name="VkPipelineCacheHeaderVersionOne">
- <comment>The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout.</comment>
- <member><type>uint32_t</type> <name>headerSize</name></member>
- <member><type>VkPipelineCacheHeaderVersion</type> <name>headerVersion</name></member>
- <member><type>uint32_t</type> <name>vendorID</name></member>
- <member><type>uint32_t</type> <name>deviceID</name></member>
- <member><type>uint8_t</type> <name>pipelineCacheUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
- </type>
- <type category="struct" name="VkPushConstantRange">
- <member><type>VkShaderStageFlags</type> <name>stageFlags</name><comment>Which stages use the range</comment></member>
- <member><type>uint32_t</type> <name>offset</name><comment>Start of the range, in bytes</comment></member>
- <member><type>uint32_t</type> <name>size</name><comment>Size of the range, in bytes</comment></member>
- </type>
- <type category="struct" name="VkPipelineLayoutCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineLayoutCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>setLayoutCount</name><comment>Number of descriptor sets interfaced by the pipeline</comment></member>
- <member len="setLayoutCount">const <type>VkDescriptorSetLayout</type>* <name>pSetLayouts</name><comment>Array of setCount number of descriptor set layout objects defining the layout of the</comment></member>
- <member optional="true"><type>uint32_t</type> <name>pushConstantRangeCount</name><comment>Number of push-constant ranges used by the pipeline</comment></member>
- <member len="pushConstantRangeCount">const <type>VkPushConstantRange</type>* <name>pPushConstantRanges</name><comment>Array of pushConstantRangeCount number of ranges used by various shader stages</comment></member>
- </type>
- <type category="struct" name="VkSamplerCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSamplerCreateFlags</type> <name>flags</name></member>
- <member><type>VkFilter</type> <name>magFilter</name><comment>Filter mode for magnification</comment></member>
- <member><type>VkFilter</type> <name>minFilter</name><comment>Filter mode for minifiation</comment></member>
- <member><type>VkSamplerMipmapMode</type> <name>mipmapMode</name><comment>Mipmap selection mode</comment></member>
- <member><type>VkSamplerAddressMode</type> <name>addressModeU</name></member>
- <member><type>VkSamplerAddressMode</type> <name>addressModeV</name></member>
- <member><type>VkSamplerAddressMode</type> <name>addressModeW</name></member>
- <member><type>float</type> <name>mipLodBias</name></member>
- <member><type>VkBool32</type> <name>anisotropyEnable</name></member>
- <member><type>float</type> <name>maxAnisotropy</name></member>
- <member><type>VkBool32</type> <name>compareEnable</name></member>
- <member noautovalidity="true"><type>VkCompareOp</type> <name>compareOp</name></member>
- <member><type>float</type> <name>minLod</name></member>
- <member><type>float</type> <name>maxLod</name></member>
- <member noautovalidity="true"><type>VkBorderColor</type> <name>borderColor</name></member>
- <member><type>VkBool32</type> <name>unnormalizedCoordinates</name></member>
- </type>
- <type category="struct" name="VkCommandPoolCreateInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkCommandPoolCreateFlags</type> <name>flags</name><comment>Command pool creation flags</comment></member>
- <member><type>uint32_t</type> <name>queueFamilyIndex</name></member>
- </type>
- <type category="struct" name="VkCommandBufferAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkCommandPool</type> <name>commandPool</name></member>
- <member><type>VkCommandBufferLevel</type> <name>level</name></member>
- <member><type>uint32_t</type> <name>commandBufferCount</name></member>
- </type>
- <type category="struct" name="VkCommandBufferInheritanceInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true" noautovalidity="true"><type>VkRenderPass</type> <name>renderPass</name><comment>Render pass for secondary command buffers</comment></member>
- <member><type>uint32_t</type> <name>subpass</name></member>
- <member optional="true" noautovalidity="true"><type>VkFramebuffer</type> <name>framebuffer</name><comment>Framebuffer for secondary command buffers</comment></member>
- <member><type>VkBool32</type> <name>occlusionQueryEnable</name><comment>Whether this secondary command buffer may be executed during an occlusion query</comment></member>
- <member optional="true" noautovalidity="true"><type>VkQueryControlFlags</type> <name>queryFlags</name><comment>Query flags used by this secondary command buffer, if executed during an occlusion query</comment></member>
- <member optional="true" noautovalidity="true"><type>VkQueryPipelineStatisticFlags</type> <name>pipelineStatistics</name><comment>Pipeline statistics that may be counted for this secondary command buffer</comment></member>
- </type>
- <type category="struct" name="VkCommandBufferBeginInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkCommandBufferUsageFlags</type> <name>flags</name><comment>Command buffer usage flags</comment></member>
- <member optional="true" noautovalidity="true">const <type>VkCommandBufferInheritanceInfo</type>* <name>pInheritanceInfo</name><comment>Pointer to inheritance info for secondary command buffers</comment></member>
- </type>
- <type category="struct" name="VkRenderPassBeginInfo">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkRenderPass</type> <name>renderPass</name></member>
- <member><type>VkFramebuffer</type> <name>framebuffer</name></member>
- <member><type>VkRect2D</type> <name>renderArea</name></member>
- <member optional="true"><type>uint32_t</type> <name>clearValueCount</name></member>
- <member len="clearValueCount" noautovalidity="true">const <type>VkClearValue</type>* <name>pClearValues</name></member>
- </type>
- <type category="union" name="VkClearColorValue" comment="// Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared.">
- <member><type>float</type> <name>float32</name>[4]</member>
- <member><type>int32_t</type> <name>int32</name>[4]</member>
- <member><type>uint32_t</type> <name>uint32</name>[4]</member>
- </type>
- <type category="struct" name="VkClearDepthStencilValue">
- <member><type>float</type> <name>depth</name></member>
- <member><type>uint32_t</type> <name>stencil</name></member>
- </type>
- <type category="union" name="VkClearValue" comment="// Union allowing specification of color or depth and stencil values. Actual value selected is based on attachment being cleared.">
- <member noautovalidity="true"><type>VkClearColorValue</type> <name>color</name></member>
- <member><type>VkClearDepthStencilValue</type> <name>depthStencil</name></member>
- </type>
- <type category="struct" name="VkClearAttachment">
- <member><type>VkImageAspectFlags</type> <name>aspectMask</name></member>
- <member><type>uint32_t</type> <name>colorAttachment</name></member>
- <member noautovalidity="true"><type>VkClearValue</type> <name>clearValue</name></member>
- </type>
- <type category="struct" name="VkAttachmentDescription">
- <member optional="true"><type>VkAttachmentDescriptionFlags</type> <name>flags</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkSampleCountFlagBits</type> <name>samples</name></member>
- <member><type>VkAttachmentLoadOp</type> <name>loadOp</name><comment>Load operation for color or depth data</comment></member>
- <member><type>VkAttachmentStoreOp</type> <name>storeOp</name><comment>Store operation for color or depth data</comment></member>
- <member><type>VkAttachmentLoadOp</type> <name>stencilLoadOp</name><comment>Load operation for stencil data</comment></member>
- <member><type>VkAttachmentStoreOp</type> <name>stencilStoreOp</name><comment>Store operation for stencil data</comment></member>
- <member><type>VkImageLayout</type> <name>initialLayout</name></member>
- <member><type>VkImageLayout</type> <name>finalLayout</name></member>
- </type>
- <type category="struct" name="VkAttachmentReference">
- <member><type>uint32_t</type> <name>attachment</name></member>
- <member><type>VkImageLayout</type> <name>layout</name></member>
- </type>
- <type category="struct" name="VkSubpassDescription">
- <member optional="true"><type>VkSubpassDescriptionFlags</type> <name>flags</name></member>
- <member><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name><comment>Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now</comment></member>
- <member optional="true"><type>uint32_t</type> <name>inputAttachmentCount</name></member>
- <member len="inputAttachmentCount">const <type>VkAttachmentReference</type>* <name>pInputAttachments</name></member>
- <member optional="true"><type>uint32_t</type> <name>colorAttachmentCount</name></member>
- <member len="colorAttachmentCount">const <type>VkAttachmentReference</type>* <name>pColorAttachments</name></member>
- <member optional="true" len="colorAttachmentCount">const <type>VkAttachmentReference</type>* <name>pResolveAttachments</name></member>
- <member optional="true">const <type>VkAttachmentReference</type>* <name>pDepthStencilAttachment</name></member>
- <member optional="true"><type>uint32_t</type> <name>preserveAttachmentCount</name></member>
- <member len="preserveAttachmentCount">const <type>uint32_t</type>* <name>pPreserveAttachments</name></member>
- </type>
- <type category="struct" name="VkSubpassDependency">
- <member><type>uint32_t</type> <name>srcSubpass</name></member>
- <member><type>uint32_t</type> <name>dstSubpass</name></member>
- <member optional="true"><type>VkPipelineStageFlags</type> <name>srcStageMask</name></member>
- <member optional="true"><type>VkPipelineStageFlags</type> <name>dstStageMask</name></member>
- <member optional="true"><type>VkAccessFlags</type> <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
- <member optional="true"><type>VkAccessFlags</type> <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
- <member optional="true"><type>VkDependencyFlags</type> <name>dependencyFlags</name></member>
- </type>
- <type category="struct" name="VkRenderPassCreateInfo">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkRenderPassCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentCount</name></member>
- <member len="attachmentCount">const <type>VkAttachmentDescription</type>* <name>pAttachments</name></member>
- <member><type>uint32_t</type> <name>subpassCount</name></member>
- <member len="subpassCount">const <type>VkSubpassDescription</type>* <name>pSubpasses</name></member>
- <member optional="true"><type>uint32_t</type> <name>dependencyCount</name></member>
- <member len="dependencyCount">const <type>VkSubpassDependency</type>* <name>pDependencies</name></member>
- </type>
- <type category="struct" name="VkEventCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkEventCreateFlags</type> <name>flags</name><comment>Event creation flags</comment></member>
- </type>
- <type category="struct" name="VkFenceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkFenceCreateFlags</type> <name>flags</name><comment>Fence creation flags</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFeatures">
- <member><type>VkBool32</type> <name>robustBufferAccess</name><comment>out of bounds buffer accesses are well defined</comment></member>
- <member><type>VkBool32</type> <name>fullDrawIndexUint32</name><comment>full 32-bit range of indices for indexed draw calls</comment></member>
- <member><type>VkBool32</type> <name>imageCubeArray</name><comment>image views which are arrays of cube maps</comment></member>
- <member><type>VkBool32</type> <name>independentBlend</name><comment>blending operations are controlled per-attachment</comment></member>
- <member><type>VkBool32</type> <name>geometryShader</name><comment>geometry stage</comment></member>
- <member><type>VkBool32</type> <name>tessellationShader</name><comment>tessellation control and evaluation stage</comment></member>
- <member><type>VkBool32</type> <name>sampleRateShading</name><comment>per-sample shading and interpolation</comment></member>
- <member><type>VkBool32</type> <name>dualSrcBlend</name><comment>blend operations which take two sources</comment></member>
- <member><type>VkBool32</type> <name>logicOp</name><comment>logic operations</comment></member>
- <member><type>VkBool32</type> <name>multiDrawIndirect</name><comment>multi draw indirect</comment></member>
- <member><type>VkBool32</type> <name>drawIndirectFirstInstance</name><comment>indirect draws can use non-zero firstInstance</comment></member>
- <member><type>VkBool32</type> <name>depthClamp</name><comment>depth clamping</comment></member>
- <member><type>VkBool32</type> <name>depthBiasClamp</name><comment>depth bias clamping</comment></member>
- <member><type>VkBool32</type> <name>fillModeNonSolid</name><comment>point and wireframe fill modes</comment></member>
- <member><type>VkBool32</type> <name>depthBounds</name><comment>depth bounds test</comment></member>
- <member><type>VkBool32</type> <name>wideLines</name><comment>lines with width greater than 1</comment></member>
- <member><type>VkBool32</type> <name>largePoints</name><comment>points with size greater than 1</comment></member>
- <member><type>VkBool32</type> <name>alphaToOne</name><comment>the fragment alpha component can be forced to maximum representable alpha value</comment></member>
- <member><type>VkBool32</type> <name>multiViewport</name><comment>viewport arrays</comment></member>
- <member><type>VkBool32</type> <name>samplerAnisotropy</name><comment>anisotropic sampler filtering</comment></member>
- <member><type>VkBool32</type> <name>textureCompressionETC2</name><comment>ETC texture compression formats</comment></member>
- <member><type>VkBool32</type> <name>textureCompressionASTC_LDR</name><comment>ASTC LDR texture compression formats</comment></member>
- <member><type>VkBool32</type> <name>textureCompressionBC</name><comment>BC1-7 texture compressed formats</comment></member>
- <member><type>VkBool32</type> <name>occlusionQueryPrecise</name><comment>precise occlusion queries returning actual sample counts</comment></member>
- <member><type>VkBool32</type> <name>pipelineStatisticsQuery</name><comment>pipeline statistics query</comment></member>
- <member><type>VkBool32</type> <name>vertexPipelineStoresAndAtomics</name><comment>stores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages</comment></member>
- <member><type>VkBool32</type> <name>fragmentStoresAndAtomics</name><comment>stores and atomic ops on storage buffers and images are supported in the fragment stage</comment></member>
- <member><type>VkBool32</type> <name>shaderTessellationAndGeometryPointSize</name><comment>tessellation and geometry stages can export point size</comment></member>
- <member><type>VkBool32</type> <name>shaderImageGatherExtended</name><comment>image gather with run-time values and independent offsets</comment></member>
- <member><type>VkBool32</type> <name>shaderStorageImageExtendedFormats</name><comment>the extended set of formats can be used for storage images</comment></member>
- <member><type>VkBool32</type> <name>shaderStorageImageMultisample</name><comment>multisample images can be used for storage images</comment></member>
- <member><type>VkBool32</type> <name>shaderStorageImageReadWithoutFormat</name><comment>read from storage image does not require format qualifier</comment></member>
- <member><type>VkBool32</type> <name>shaderStorageImageWriteWithoutFormat</name><comment>write to storage image does not require format qualifier</comment></member>
- <member><type>VkBool32</type> <name>shaderUniformBufferArrayDynamicIndexing</name><comment>arrays of uniform buffers can be accessed with dynamically uniform indices</comment></member>
- <member><type>VkBool32</type> <name>shaderSampledImageArrayDynamicIndexing</name><comment>arrays of sampled images can be accessed with dynamically uniform indices</comment></member>
- <member><type>VkBool32</type> <name>shaderStorageBufferArrayDynamicIndexing</name><comment>arrays of storage buffers can be accessed with dynamically uniform indices</comment></member>
- <member><type>VkBool32</type> <name>shaderStorageImageArrayDynamicIndexing</name><comment>arrays of storage images can be accessed with dynamically uniform indices</comment></member>
- <member><type>VkBool32</type> <name>shaderClipDistance</name><comment>clip distance in shaders</comment></member>
- <member><type>VkBool32</type> <name>shaderCullDistance</name><comment>cull distance in shaders</comment></member>
- <member><type>VkBool32</type> <name>shaderFloat64</name><comment>64-bit floats (doubles) in shaders</comment></member>
- <member><type>VkBool32</type> <name>shaderInt64</name><comment>64-bit integers in shaders</comment></member>
- <member><type>VkBool32</type> <name>shaderInt16</name><comment>16-bit integers in shaders</comment></member>
- <member><type>VkBool32</type> <name>shaderResourceResidency</name><comment>shader can use texture operations that return resource residency information (requires sparseNonResident support)</comment></member>
- <member><type>VkBool32</type> <name>shaderResourceMinLod</name><comment>shader can use texture operations that specify minimum resource LOD</comment></member>
- <member><type>VkBool32</type> <name>sparseBinding</name><comment>Sparse resources support: Resource memory can be managed at opaque page level rather than object level</comment></member>
- <member><type>VkBool32</type> <name>sparseResidencyBuffer</name><comment>Sparse resources support: GPU can access partially resident buffers </comment></member>
- <member><type>VkBool32</type> <name>sparseResidencyImage2D</name><comment>Sparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images </comment></member>
- <member><type>VkBool32</type> <name>sparseResidencyImage3D</name><comment>Sparse resources support: GPU can access partially resident 3D images </comment></member>
- <member><type>VkBool32</type> <name>sparseResidency2Samples</name><comment>Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples</comment></member>
- <member><type>VkBool32</type> <name>sparseResidency4Samples</name><comment>Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples</comment></member>
- <member><type>VkBool32</type> <name>sparseResidency8Samples</name><comment>Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples</comment></member>
- <member><type>VkBool32</type> <name>sparseResidency16Samples</name><comment>Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples</comment></member>
- <member><type>VkBool32</type> <name>sparseResidencyAliased</name><comment>Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)</comment></member>
- <member><type>VkBool32</type> <name>variableMultisampleRate</name><comment>multisample rate must be the same for all pipelines in a subpass</comment></member>
- <member><type>VkBool32</type> <name>inheritedQueries</name><comment>Queries may be inherited from primary to secondary command buffers</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSparseProperties" returnedonly="true">
- <member limittype="bitmask"><type>VkBool32</type> <name>residencyStandard2DBlockShape</name><comment>Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>residencyStandard2DMultisampleBlockShape</name><comment>Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>residencyStandard3DBlockShape</name><comment>Sparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>residencyAlignedMipSize</name><comment>Sparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>residencyNonResidentStrict</name><comment>Sparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceLimits" returnedonly="true">
- <comment>resource maximum sizes</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxImageDimension1D</name><comment>max 1D image dimension</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxImageDimension2D</name><comment>max 2D image dimension</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxImageDimension3D</name><comment>max 3D image dimension</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxImageDimensionCube</name><comment>max cubemap image dimension</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxImageArrayLayers</name><comment>max layers for image arrays</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTexelBufferElements</name><comment>max texel buffer size (fstexels)</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxUniformBufferRange</name><comment>max uniform buffer range (bytes)</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxStorageBufferRange</name><comment>max storage buffer range (bytes)</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPushConstantsSize</name><comment>max size of the push constants pool (bytes)</comment></member>
- <comment>memory limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxMemoryAllocationCount</name><comment>max number of device memory allocations supported</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxSamplerAllocationCount</name><comment>max number of samplers that can be allocated on a device</comment></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>bufferImageGranularity</name><comment>Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage</comment></member>
- <member limittype="max"><type>VkDeviceSize</type> <name>sparseAddressSpaceSize</name><comment>Total address space available for sparse allocations (bytes)</comment></member>
- <comment>descriptor set limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxBoundDescriptorSets</name><comment>max number of descriptors sets that can be bound to a pipeline</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorSamplers</name><comment>max number of samplers allowed per-stage in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUniformBuffers</name><comment>max number of uniform buffers allowed per-stage in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorStorageBuffers</name><comment>max number of storage buffers allowed per-stage in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorSampledImages</name><comment>max number of sampled images allowed per-stage in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorStorageImages</name><comment>max number of storage images allowed per-stage in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorInputAttachments</name><comment>max number of input attachments allowed per-stage in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageResources</name><comment>max number of resources allowed by a single stage</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetSamplers</name><comment>max number of samplers allowed in all stages in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUniformBuffers</name><comment>max number of uniform buffers allowed in all stages in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUniformBuffersDynamic</name><comment>max number of dynamic uniform buffers allowed in all stages in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetStorageBuffers</name><comment>max number of storage buffers allowed in all stages in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetStorageBuffersDynamic</name><comment>max number of dynamic storage buffers allowed in all stages in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetSampledImages</name><comment>max number of sampled images allowed in all stages in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetStorageImages</name><comment>max number of storage images allowed in all stages in a descriptor set</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetInputAttachments</name><comment>max number of input attachments allowed in all stages in a descriptor set</comment></member>
- <comment>vertex stage limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxVertexInputAttributes</name><comment>max number of vertex input attribute slots</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxVertexInputBindings</name><comment>max number of vertex input binding slots</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxVertexInputAttributeOffset</name><comment>max vertex input attribute offset added to vertex buffer offset</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxVertexInputBindingStride</name><comment>max vertex input binding stride</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxVertexOutputComponents</name><comment>max number of output components written by vertex shader</comment></member>
- <comment>tessellation control stage limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationGenerationLevel</name><comment>max level supported by tessellation primitive generator</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationPatchSize</name><comment>max patch size (vertices)</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationControlPerVertexInputComponents</name><comment>max number of input components per-vertex in TCS</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationControlPerVertexOutputComponents</name><comment>max number of output components per-vertex in TCS</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationControlPerPatchOutputComponents</name><comment>max number of output components per-patch in TCS</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationControlTotalOutputComponents</name><comment>max total number of per-vertex and per-patch output components in TCS</comment></member>
- <comment>tessellation evaluation stage limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationEvaluationInputComponents</name><comment>max number of input components per vertex in TES</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTessellationEvaluationOutputComponents</name><comment>max number of output components per vertex in TES</comment></member>
- <comment>geometry stage limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxGeometryShaderInvocations</name><comment>max invocation count supported in geometry shader</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxGeometryInputComponents</name><comment>max number of input components read in geometry stage</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxGeometryOutputComponents</name><comment>max number of output components written in geometry stage</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxGeometryOutputVertices</name><comment>max number of vertices that can be emitted in geometry stage</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxGeometryTotalOutputComponents</name><comment>max total number of components (all vertices) written in geometry stage</comment></member>
- <comment>fragment stage limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxFragmentInputComponents</name><comment>max number of input components read in fragment stage</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxFragmentOutputAttachments</name><comment>max number of output attachments written in fragment stage</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxFragmentDualSrcAttachments</name><comment>max number of output attachments written when using dual source blending</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxFragmentCombinedOutputResources</name><comment>max total number of storage buffers, storage images and output buffers</comment></member>
- <comment>compute stage limits</comment>
- <member limittype="max"><type>uint32_t</type> <name>maxComputeSharedMemorySize</name><comment>max total storage size of work group local storage (bytes)</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxComputeWorkGroupCount</name>[3]<comment>max num of compute work groups that may be dispatched by a single command (x,y,z)</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxComputeWorkGroupInvocations</name><comment>max total compute invocations in a single local work group</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxComputeWorkGroupSize</name>[3]<comment>max local size of a compute work group (x,y,z)</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>subPixelPrecisionBits</name><comment>number bits of subpixel precision in screen x and y</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>subTexelPrecisionBits</name><comment>number bits of precision for selecting texel weights</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>mipmapPrecisionBits</name><comment>number bits of precision for selecting mipmap weights</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDrawIndexedIndexValue</name><comment>max index value for indexed draw calls (for 32-bit indices)</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDrawIndirectCount</name><comment>max draw count for indirect draw calls</comment></member>
- <member limittype="max"><type>float</type> <name>maxSamplerLodBias</name><comment>max absolute sampler LOD bias</comment></member>
- <member limittype="max"><type>float</type> <name>maxSamplerAnisotropy</name><comment>max degree of sampler anisotropy</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxViewports</name><comment>max number of active viewports</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxViewportDimensions</name>[2]<comment>max viewport dimensions (x,y)</comment></member>
- <member limittype="range"><type>float</type> <name>viewportBoundsRange</name>[2]<comment>viewport bounds range (min,max)</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>viewportSubPixelBits</name><comment>number bits of subpixel precision for viewport</comment></member>
- <member limittype="noauto"><type>size_t</type> <name>minMemoryMapAlignment</name><comment>min required alignment of pointers returned by MapMemory (bytes)</comment></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>minTexelBufferOffsetAlignment</name><comment>min required alignment for texel buffer offsets (bytes) </comment></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>minUniformBufferOffsetAlignment</name><comment>min required alignment for uniform buffer sizes and offsets (bytes)</comment></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>minStorageBufferOffsetAlignment</name><comment>min required alignment for storage buffer offsets (bytes)</comment></member>
- <member limittype="min"><type>int32_t</type> <name>minTexelOffset</name><comment>min texel offset for OpTextureSampleOffset</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTexelOffset</name><comment>max texel offset for OpTextureSampleOffset</comment></member>
- <member limittype="min"><type>int32_t</type> <name>minTexelGatherOffset</name><comment>min texel offset for OpTextureGatherOffset</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTexelGatherOffset</name><comment>max texel offset for OpTextureGatherOffset</comment></member>
- <member limittype="min"><type>float</type> <name>minInterpolationOffset</name><comment>furthest negative offset for interpolateAtOffset</comment></member>
- <member limittype="max"><type>float</type> <name>maxInterpolationOffset</name><comment>furthest positive offset for interpolateAtOffset</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>subPixelInterpolationOffsetBits</name><comment>number of subpixel bits for interpolateAtOffset</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxFramebufferWidth</name><comment>max width for a framebuffer</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxFramebufferHeight</name><comment>max height for a framebuffer</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxFramebufferLayers</name><comment>max layer count for a layered framebuffer</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>framebufferColorSampleCounts</name><comment>supported color sample counts for a framebuffer</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>framebufferDepthSampleCounts</name><comment>supported depth sample counts for a framebuffer</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>framebufferStencilSampleCounts</name><comment>supported stencil sample counts for a framebuffer</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>framebufferNoAttachmentsSampleCounts</name><comment>supported sample counts for a subpass which uses no attachments</comment></member>
- <member limittype="bitmask"><type>uint32_t</type> <name>maxColorAttachments</name><comment>max number of color attachments per subpass</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>sampledImageColorSampleCounts</name><comment>supported color sample counts for a non-integer sampled image</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>sampledImageIntegerSampleCounts</name><comment>supported sample counts for an integer image</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>sampledImageDepthSampleCounts</name><comment>supported depth sample counts for a sampled image</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>sampledImageStencilSampleCounts</name><comment>supported stencil sample counts for a sampled image</comment></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>storageImageSampleCounts</name><comment>supported sample counts for a storage image</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxSampleMaskWords</name><comment>max number of sample mask words</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>timestampComputeAndGraphics</name><comment>timestamps on graphics and compute queues</comment></member>
- <member limittype="noauto"><type>float</type> <name>timestampPeriod</name><comment>number of nanoseconds it takes for timestamp query value to increment by 1</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxClipDistances</name><comment>max number of clip distances</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxCullDistances</name><comment>max number of cull distances</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxCombinedClipAndCullDistances</name><comment>max combined number of user clipping</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>discreteQueuePriorities</name><comment>distinct queue priorities available </comment></member>
- <member limittype="range"><type>float</type> <name>pointSizeRange</name>[2]<comment>range (min,max) of supported point sizes</comment></member>
- <member limittype="range"><type>float</type> <name>lineWidthRange</name>[2]<comment>range (min,max) of supported line widths</comment></member>
- <member limittype="max"><type>float</type> <name>pointSizeGranularity</name><comment>granularity of supported point sizes</comment></member>
- <member limittype="max"><type>float</type> <name>lineWidthGranularity</name><comment>granularity of supported line widths</comment></member>
- <member limittype="noauto"><type>VkBool32</type> <name>strictLines</name><comment>line rasterization follows preferred rules</comment></member>
- <member limittype="noauto"><type>VkBool32</type> <name>standardSampleLocations</name><comment>supports standard sample locations for all supported sample counts</comment></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>optimalBufferCopyOffsetAlignment</name><comment>optimal offset of buffer copies</comment></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>optimalBufferCopyRowPitchAlignment</name><comment>optimal pitch of buffer copies</comment></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>nonCoherentAtomSize</name><comment>minimum size and alignment for non-coherent host-mapped device memory access</comment></member>
- </type>
- <type category="struct" name="VkSemaphoreCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSemaphoreCreateFlags</type> <name>flags</name><comment>Semaphore creation flags</comment></member>
- </type>
- <type category="struct" name="VkQueryPoolCreateInfo">
- <member values="VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkQueryPoolCreateFlags</type> <name>flags</name></member>
- <member><type>VkQueryType</type> <name>queryType</name></member>
- <member><type>uint32_t</type> <name>queryCount</name></member>
- <member optional="true" noautovalidity="true"><type>VkQueryPipelineStatisticFlags</type> <name>pipelineStatistics</name><comment>Optional</comment></member>
- </type>
- <type category="struct" name="VkFramebufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkFramebufferCreateFlags</type> <name>flags</name></member>
- <member><type>VkRenderPass</type> <name>renderPass</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentCount</name></member>
- <member len="attachmentCount">const <type>VkImageView</type>* <name>pAttachments</name></member>
- <member><type>uint32_t</type> <name>width</name></member>
- <member><type>uint32_t</type> <name>height</name></member>
- <member><type>uint32_t</type> <name>layers</name></member>
- </type>
- <type category="struct" name="VkDrawIndirectCommand">
- <member><type>uint32_t</type> <name>vertexCount</name></member>
- <member><type>uint32_t</type> <name>instanceCount</name></member>
- <member><type>uint32_t</type> <name>firstVertex</name></member>
- <member noautovalidity="true"><type>uint32_t</type> <name>firstInstance</name></member>
- </type>
- <type category="struct" name="VkDrawIndexedIndirectCommand">
- <member><type>uint32_t</type> <name>indexCount</name></member>
- <member><type>uint32_t</type> <name>instanceCount</name></member>
- <member><type>uint32_t</type> <name>firstIndex</name></member>
- <member><type>int32_t</type> <name>vertexOffset</name></member>
- <member noautovalidity="true"><type>uint32_t</type> <name>firstInstance</name></member>
- </type>
- <type category="struct" name="VkDispatchIndirectCommand">
- <member noautovalidity="true"><type>uint32_t</type> <name>x</name></member>
- <member noautovalidity="true"><type>uint32_t</type> <name>y</name></member>
- <member noautovalidity="true"><type>uint32_t</type> <name>z</name></member>
- </type>
- <type category="struct" name="VkMultiDrawInfoEXT">
- <member><type>uint32_t</type> <name>firstVertex</name></member>
- <member><type>uint32_t</type> <name>vertexCount</name></member>
- </type>
- <type category="struct" name="VkMultiDrawIndexedInfoEXT">
- <member><type>uint32_t</type> <name>firstIndex</name></member>
- <member><type>uint32_t</type> <name>indexCount</name></member>
- <member><type>int32_t</type> <name>vertexOffset</name></member>
- </type>
- <type category="struct" name="VkSubmitInfo">
- <member values="VK_STRUCTURE_TYPE_SUBMIT_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></member>
- <member len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></member>
- <member len="waitSemaphoreCount">const <type>VkPipelineStageFlags</type>* <name>pWaitDstStageMask</name></member>
- <member optional="true"><type>uint32_t</type> <name>commandBufferCount</name></member>
- <member len="commandBufferCount">const <type>VkCommandBuffer</type>* <name>pCommandBuffers</name></member>
- <member optional="true"><type>uint32_t</type> <name>signalSemaphoreCount</name></member>
- <member len="signalSemaphoreCount">const <type>VkSemaphore</type>* <name>pSignalSemaphores</name></member>
- </type>
- <comment>WSI extensions</comment>
- <type category="struct" name="VkDisplayPropertiesKHR" returnedonly="true">
- <member><type>VkDisplayKHR</type> <name>display</name><comment>Handle of the display object</comment></member>
- <member len="null-terminated">const <type>char</type>* <name>displayName</name><comment>Name of the display</comment></member>
- <member><type>VkExtent2D</type> <name>physicalDimensions</name><comment>In millimeters?</comment></member>
- <member><type>VkExtent2D</type> <name>physicalResolution</name><comment>Max resolution for CRT?</comment></member>
- <member optional="true"><type>VkSurfaceTransformFlagsKHR</type> <name>supportedTransforms</name><comment>one or more bits from VkSurfaceTransformFlagsKHR</comment></member>
- <member><type>VkBool32</type> <name>planeReorderPossible</name><comment>VK_TRUE if the overlay plane's z-order can be changed on this display.</comment></member>
- <member><type>VkBool32</type> <name>persistentContent</name><comment>VK_TRUE if this is a "smart" display that supports self-refresh/internal buffering.</comment></member>
- </type>
- <type category="struct" name="VkDisplayPlanePropertiesKHR" returnedonly="true">
- <member><type>VkDisplayKHR</type> <name>currentDisplay</name><comment>Display the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use.</comment></member>
- <member><type>uint32_t</type> <name>currentStackIndex</name><comment>Current z-order of the plane.</comment></member>
- </type>
- <type category="struct" name="VkDisplayModeParametersKHR">
- <member><type>VkExtent2D</type> <name>visibleRegion</name><comment>Visible scanout region.</comment></member>
- <member noautovalidity="true"><type>uint32_t</type> <name>refreshRate</name><comment>Number of times per second the display is updated.</comment></member>
- </type>
- <type category="struct" name="VkDisplayModePropertiesKHR" returnedonly="true">
- <member><type>VkDisplayModeKHR</type> <name>displayMode</name><comment>Handle of this display mode.</comment></member>
- <member><type>VkDisplayModeParametersKHR</type> <name>parameters</name><comment>The parameters this mode uses.</comment></member>
- </type>
- <type category="struct" name="VkDisplayModeCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDisplayModeCreateFlagsKHR</type> <name>flags</name></member>
- <member><type>VkDisplayModeParametersKHR</type> <name>parameters</name><comment>The parameters this mode uses.</comment></member>
- </type>
- <type category="struct" name="VkDisplayPlaneCapabilitiesKHR" returnedonly="true">
- <member optional="true"><type>VkDisplayPlaneAlphaFlagsKHR</type> <name>supportedAlpha</name><comment>Types of alpha blending supported, if any.</comment></member>
- <member><type>VkOffset2D</type> <name>minSrcPosition</name><comment>Does the plane have any position and extent restrictions?</comment></member>
- <member><type>VkOffset2D</type> <name>maxSrcPosition</name></member>
- <member><type>VkExtent2D</type> <name>minSrcExtent</name></member>
- <member><type>VkExtent2D</type> <name>maxSrcExtent</name></member>
- <member><type>VkOffset2D</type> <name>minDstPosition</name></member>
- <member><type>VkOffset2D</type> <name>maxDstPosition</name></member>
- <member><type>VkExtent2D</type> <name>minDstExtent</name></member>
- <member><type>VkExtent2D</type> <name>maxDstExtent</name></member>
- </type>
- <type category="struct" name="VkDisplaySurfaceCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDisplaySurfaceCreateFlagsKHR</type> <name>flags</name></member>
- <member><type>VkDisplayModeKHR</type> <name>displayMode</name><comment>The mode to use when displaying this surface</comment></member>
- <member><type>uint32_t</type> <name>planeIndex</name><comment>The plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount.</comment></member>
- <member><type>uint32_t</type> <name>planeStackIndex</name><comment>The z-order of the plane.</comment></member>
- <member><type>VkSurfaceTransformFlagBitsKHR</type> <name>transform</name><comment>Transform to apply to the images as part of the scanout operation</comment></member>
- <member><type>float</type> <name>globalAlpha</name><comment>Global alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR</comment></member>
- <member><type>VkDisplayPlaneAlphaFlagBitsKHR</type> <name>alphaMode</name><comment>What type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha.</comment></member>
- <member><type>VkExtent2D</type> <name>imageExtent</name><comment>size of the images to use with this surface</comment></member>
- </type>
- <type category="struct" name="VkDisplayPresentInfoKHR" structextends="VkPresentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkRect2D</type> <name>srcRect</name><comment>Rectangle within the presentable image to read pixel data from when presenting to the display.</comment></member>
- <member><type>VkRect2D</type> <name>dstRect</name><comment>Rectangle within the current display mode's visible region to display srcRectangle in.</comment></member>
- <member><type>VkBool32</type> <name>persistent</name><comment>For smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE.</comment></member>
- </type>
- <type category="struct" name="VkSurfaceCapabilitiesKHR" returnedonly="true">
- <member><type>uint32_t</type> <name>minImageCount</name><comment>Supported minimum number of images for the surface</comment></member>
- <member><type>uint32_t</type> <name>maxImageCount</name><comment>Supported maximum number of images for the surface, 0 for unlimited</comment></member>
- <member><type>VkExtent2D</type> <name>currentExtent</name><comment>Current image width and height for the surface, (0, 0) if undefined</comment></member>
- <member><type>VkExtent2D</type> <name>minImageExtent</name><comment>Supported minimum image width and height for the surface</comment></member>
- <member><type>VkExtent2D</type> <name>maxImageExtent</name><comment>Supported maximum image width and height for the surface</comment></member>
- <member><type>uint32_t</type> <name>maxImageArrayLayers</name><comment>Supported maximum number of image layers for the surface</comment></member>
- <member><type>VkSurfaceTransformFlagsKHR</type> <name>supportedTransforms</name><comment>1 or more bits representing the transforms supported</comment></member>
- <member><type>VkSurfaceTransformFlagBitsKHR</type> <name>currentTransform</name><comment>The surface's current transform relative to the device's natural orientation</comment></member>
- <member><type>VkCompositeAlphaFlagsKHR</type> <name>supportedCompositeAlpha</name><comment>1 or more bits representing the alpha compositing modes supported</comment></member>
- <member><type>VkImageUsageFlags</type> <name>supportedUsageFlags</name><comment>Supported image usage flags for the surface</comment></member>
- </type>
- <type category="struct" name="VkAndroidSurfaceCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkAndroidSurfaceCreateFlagsKHR</type> <name>flags</name></member>
- <member noautovalidity="true">struct <type>ANativeWindow</type>* <name>window</name></member>
- </type>
- <type category="struct" name="VkViSurfaceCreateInfoNN">
- <member values="VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkViSurfaceCreateFlagsNN</type> <name>flags</name></member>
- <member noautovalidity="true"><type>void</type>* <name>window</name></member>
- </type>
- <type category="struct" name="VkWaylandSurfaceCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkWaylandSurfaceCreateFlagsKHR</type> <name>flags</name></member>
- <member noautovalidity="true">struct <type>wl_display</type>* <name>display</name></member>
- <member noautovalidity="true">struct <type>wl_surface</type>* <name>surface</name></member>
- </type>
- <type category="struct" name="VkWin32SurfaceCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkWin32SurfaceCreateFlagsKHR</type> <name>flags</name></member>
- <member><type>HINSTANCE</type> <name>hinstance</name></member>
- <member><type>HWND</type> <name>hwnd</name></member>
- </type>
- <type category="struct" name="VkXlibSurfaceCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkXlibSurfaceCreateFlagsKHR</type> <name>flags</name></member>
- <member noautovalidity="true"><type>Display</type>* <name>dpy</name></member>
- <member><type>Window</type> <name>window</name></member>
- </type>
- <type category="struct" name="VkXcbSurfaceCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkXcbSurfaceCreateFlagsKHR</type> <name>flags</name></member>
- <member noautovalidity="true"><type>xcb_connection_t</type>* <name>connection</name></member>
- <member><type>xcb_window_t</type> <name>window</name></member>
- </type>
- <type category="struct" name="VkDirectFBSurfaceCreateInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDirectFBSurfaceCreateFlagsEXT</type> <name>flags</name></member>
- <member noautovalidity="true"><type>IDirectFB</type>* <name>dfb</name></member>
- <member noautovalidity="true"><type>IDirectFBSurface</type>* <name>surface</name></member>
- </type>
- <type category="struct" name="VkImagePipeSurfaceCreateInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImagePipeSurfaceCreateFlagsFUCHSIA</type> <name>flags</name></member>
- <member><type>zx_handle_t</type> <name>imagePipeHandle</name></member>
- </type>
- <type category="struct" name="VkStreamDescriptorSurfaceCreateInfoGGP">
- <member values="VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkStreamDescriptorSurfaceCreateFlagsGGP</type> <name>flags</name></member>
- <member><type>GgpStreamDescriptor</type> <name>streamDescriptor</name></member>
- </type>
- <type category="struct" name="VkScreenSurfaceCreateInfoQNX">
- <member values="VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkScreenSurfaceCreateFlagsQNX</type> <name>flags</name></member>
- <member noautovalidity="true">struct <type>_screen_context</type>* <name>context</name></member>
- <member noautovalidity="true">struct <type>_screen_window</type>* <name>window</name></member>
- </type>
- <type category="struct" name="VkSurfaceFormatKHR" returnedonly="true">
- <member><type>VkFormat</type> <name>format</name><comment>Supported pair of rendering format</comment></member>
- <member><type>VkColorSpaceKHR</type> <name>colorSpace</name><comment>and color space for the surface</comment></member>
- </type>
- <type category="struct" name="VkSwapchainCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSwapchainCreateFlagsKHR</type> <name>flags</name></member>
- <member><type>VkSurfaceKHR</type> <name>surface</name><comment>The swapchain's target surface</comment></member>
- <member><type>uint32_t</type> <name>minImageCount</name><comment>Minimum number of presentation images the application needs</comment></member>
- <member><type>VkFormat</type> <name>imageFormat</name><comment>Format of the presentation images</comment></member>
- <member><type>VkColorSpaceKHR</type> <name>imageColorSpace</name><comment>Colorspace of the presentation images</comment></member>
- <member><type>VkExtent2D</type> <name>imageExtent</name><comment>Dimensions of the presentation images</comment></member>
- <member><type>uint32_t</type> <name>imageArrayLayers</name><comment>Determines the number of views for multiview/stereo presentation</comment></member>
- <member><type>VkImageUsageFlags</type> <name>imageUsage</name><comment>Bits indicating how the presentation images will be used</comment></member>
- <member><type>VkSharingMode</type> <name>imageSharingMode</name><comment>Sharing mode used for the presentation images</comment></member>
- <member optional="true"><type>uint32_t</type> <name>queueFamilyIndexCount</name><comment>Number of queue families having access to the images in case of concurrent sharing mode</comment></member>
- <member noautovalidity="true" len="queueFamilyIndexCount">const <type>uint32_t</type>* <name>pQueueFamilyIndices</name><comment>Array of queue family indices having access to the images in case of concurrent sharing mode</comment></member>
- <member><type>VkSurfaceTransformFlagBitsKHR</type> <name>preTransform</name><comment>The transform, relative to the device's natural orientation, applied to the image content prior to presentation</comment></member>
- <member><type>VkCompositeAlphaFlagBitsKHR</type> <name>compositeAlpha</name><comment>The alpha blending mode used when compositing this surface with other surfaces in the window system</comment></member>
- <member><type>VkPresentModeKHR</type> <name>presentMode</name><comment>Which presentation mode to use for presents on this swap chain</comment></member>
- <member><type>VkBool32</type> <name>clipped</name><comment>Specifies whether presentable images may be affected by window clip regions</comment></member>
- <member optional="true"><type>VkSwapchainKHR</type> <name>oldSwapchain</name><comment>Existing swap chain to replace, if any</comment></member>
- </type>
- <type category="struct" name="VkPresentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name><comment>Number of semaphores to wait for before presenting</comment></member>
- <member len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name><comment>Semaphores to wait for before presenting</comment></member>
- <member><type>uint32_t</type> <name>swapchainCount</name><comment>Number of swapchains to present in this call</comment></member>
- <member len="swapchainCount">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name><comment>Swapchains to present an image from</comment></member>
- <member len="swapchainCount">const <type>uint32_t</type>* <name>pImageIndices</name><comment>Indices of which presentable images to present</comment></member>
- <member optional="true" len="swapchainCount"><type>VkResult</type>* <name>pResults</name><comment>Optional (i.e. if non-NULL) VkResult for each swapchain</comment></member>
- </type>
- <type category="struct" name="VkDebugReportCallbackCreateInfoEXT" structextends="VkInstanceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDebugReportFlagsEXT</type> <name>flags</name><comment>Indicates which events call this callback</comment></member>
- <member><type>PFN_vkDebugReportCallbackEXT</type> <name>pfnCallback</name><comment>Function pointer of a callback function</comment></member>
- <member optional="true"><type>void</type>* <name>pUserData</name><comment>User data provided to callback function</comment></member>
- </type>
- <type category="struct" name="VkValidationFlagsEXT" structextends="VkInstanceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT"><type>VkStructureType</type> <name>sType</name><comment>Must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT</comment></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>disabledValidationCheckCount</name><comment>Number of validation checks to disable</comment></member>
- <member len="disabledValidationCheckCount">const <type>VkValidationCheckEXT</type>* <name>pDisabledValidationChecks</name><comment>Validation checks to disable</comment></member>
- </type>
- <type category="struct" name="VkValidationFeaturesEXT" structextends="VkInstanceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name><comment>Must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT</comment></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>enabledValidationFeatureCount</name><comment>Number of validation features to enable</comment></member>
- <member len="enabledValidationFeatureCount">const <type>VkValidationFeatureEnableEXT</type>* <name>pEnabledValidationFeatures</name><comment>Validation features to enable</comment></member>
- <member optional="true"><type>uint32_t</type> <name>disabledValidationFeatureCount</name><comment>Number of validation features to disable</comment></member>
- <member len="disabledValidationFeatureCount">const <type>VkValidationFeatureDisableEXT</type>* <name>pDisabledValidationFeatures</name><comment>Validation features to disable</comment></member>
- </type>
- <type category="struct" name="VkPipelineRasterizationStateRasterizationOrderAMD" structextends="VkPipelineRasterizationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkRasterizationOrderAMD</type> <name>rasterizationOrder</name><comment>Rasterization order to use for the pipeline</comment></member>
- </type>
- <type category="struct" name="VkDebugMarkerObjectNameInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDebugReportObjectTypeEXT</type> <name>objectType</name><comment>The type of the object</comment></member>
- <member objecttype="objectType"><type>uint64_t</type> <name>object</name><comment>The handle of the object, cast to uint64_t</comment></member>
- <member len="null-terminated">const <type>char</type>* <name>pObjectName</name><comment>Name to apply to the object</comment></member>
- </type>
- <type category="struct" name="VkDebugMarkerObjectTagInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDebugReportObjectTypeEXT</type> <name>objectType</name><comment>The type of the object</comment></member>
- <member objecttype="objectType"><type>uint64_t</type> <name>object</name><comment>The handle of the object, cast to uint64_t</comment></member>
- <member><type>uint64_t</type> <name>tagName</name><comment>The name of the tag to set on the object</comment></member>
- <member><type>size_t</type> <name>tagSize</name><comment>The length in bytes of the tag data</comment></member>
- <member len="tagSize">const <type>void</type>* <name>pTag</name><comment>Tag data to attach to the object</comment></member>
- </type>
- <type category="struct" name="VkDebugMarkerMarkerInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member len="null-terminated">const <type>char</type>* <name>pMarkerName</name><comment>Name of the debug marker</comment></member>
- <member><type>float</type> <name>color</name>[4]<comment>Optional color for debug marker</comment></member>
- </type>
- <type category="struct" name="VkDedicatedAllocationImageCreateInfoNV" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>dedicatedAllocation</name><comment>Whether this image uses a dedicated allocation</comment></member>
- </type>
- <type category="struct" name="VkDedicatedAllocationBufferCreateInfoNV" structextends="VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>dedicatedAllocation</name><comment>Whether this buffer uses a dedicated allocation</comment></member>
- </type>
- <type category="struct" name="VkDedicatedAllocationMemoryAllocateInfoNV" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImage</type> <name>image</name><comment>Image that this allocation will be bound to</comment></member>
- <member optional="true"><type>VkBuffer</type> <name>buffer</name><comment>Buffer that this allocation will be bound to</comment></member>
- </type>
- <type category="struct" name="VkExternalImageFormatPropertiesNV" returnedonly="true">
- <member><type>VkImageFormatProperties</type> <name>imageFormatProperties</name></member>
- <member optional="true"><type>VkExternalMemoryFeatureFlagsNV</type> <name>externalMemoryFeatures</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagsNV</type> <name>exportFromImportedHandleTypes</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagsNV</type> <name>compatibleHandleTypes</name></member>
- </type>
- <type category="struct" name="VkExternalMemoryImageCreateInfoNV" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagsNV</type> <name>handleTypes</name></member>
- </type>
- <type category="struct" name="VkExportMemoryAllocateInfoNV" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagsNV</type> <name>handleTypes</name></member>
- </type>
- <type category="struct" name="VkImportMemoryWin32HandleInfoNV" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagsNV</type> <name>handleType</name></member>
- <member optional="true"><type>HANDLE</type> <name>handle</name></member>
- </type>
- <type category="struct" name="VkExportMemoryWin32HandleInfoNV" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true">const <type>SECURITY_ATTRIBUTES</type>* <name>pAttributes</name></member>
- <member optional="true"><type>DWORD</type> <name>dwAccess</name></member>
- </type>
- <type category="struct" name="VkWin32KeyedMutexAcquireReleaseInfoNV" structextends="VkSubmitInfo,VkSubmitInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>acquireCount</name></member>
- <member len="acquireCount" devicememoryhandle="1">const <type>VkDeviceMemory</type>* <name>pAcquireSyncs</name></member>
- <member len="acquireCount">const <type>uint64_t</type>* <name>pAcquireKeys</name></member>
- <member len="acquireCount">const <type>uint32_t</type>* <name>pAcquireTimeoutMilliseconds</name></member>
- <member optional="true"><type>uint32_t</type> <name>releaseCount</name></member>
- <member len="releaseCount" devicememoryhandle="1">const <type>VkDeviceMemory</type>* <name>pReleaseSyncs</name></member>
- <member len="releaseCount">const <type>uint64_t</type>* <name>pReleaseKeys</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>deviceGeneratedCommands</name></member>
- </type>
- <type category="struct" name="VkDevicePrivateDataCreateInfoEXT" allowduplicate="true" structextends="VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>privateDataSlotRequestCount</name></member>
- </type>
- <type category="struct" name="VkPrivateDataSlotCreateInfoEXT">
- <member values="VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPrivateDataSlotCreateFlagsEXT</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePrivateDataFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>privateData</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxGraphicsShaderGroupCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxIndirectSequenceCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxIndirectCommandsTokenCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxIndirectCommandsStreamCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxIndirectCommandsTokenOffset</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxIndirectCommandsStreamStride</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>minSequencesCountBufferOffsetAlignment</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>minSequencesIndexBufferOffsetAlignment</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>minIndirectCommandsBufferOffsetAlignment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMultiDrawPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMultiDrawCount</name></member>
- </type>
- <type category="struct" name="VkGraphicsShaderGroupCreateInfoNV">
- <member values="VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>stageCount</name></member>
- <member len="stageCount">const <type>VkPipelineShaderStageCreateInfo</type>* <name>pStages</name></member>
- <member noautovalidity="true" optional="true">const <type>VkPipelineVertexInputStateCreateInfo</type>* <name>pVertexInputState</name></member>
- <member noautovalidity="true" optional="true">const <type>VkPipelineTessellationStateCreateInfo</type>* <name>pTessellationState</name></member>
- </type>
- <type category="struct" name="VkGraphicsPipelineShaderGroupsCreateInfoNV" structextends="VkGraphicsPipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>groupCount</name></member>
- <member len="groupCount">const <type>VkGraphicsShaderGroupCreateInfoNV</type>* <name>pGroups</name></member>
- <member optional="true"><type>uint32_t</type> <name>pipelineCount</name></member>
- <member len="pipelineCount">const <type>VkPipeline</type>* <name>pPipelines</name></member>
- </type>
- <type category="struct" name="VkBindShaderGroupIndirectCommandNV">
- <member><type>uint32_t</type> <name>groupIndex</name></member>
- </type>
- <type category="struct" name="VkBindIndexBufferIndirectCommandNV">
- <member><type>VkDeviceAddress</type> <name>bufferAddress</name></member>
- <member><type>uint32_t</type> <name>size</name></member>
- <member><type>VkIndexType</type> <name>indexType</name></member>
- </type>
- <type category="struct" name="VkBindVertexBufferIndirectCommandNV">
- <member><type>VkDeviceAddress</type> <name>bufferAddress</name></member>
- <member><type>uint32_t</type> <name>size</name></member>
- <member><type>uint32_t</type> <name>stride</name></member>
- </type>
- <type category="struct" name="VkSetStateFlagsIndirectCommandNV">
- <member><type>uint32_t</type> <name>data</name></member>
- </type>
- <type category="struct" name="VkIndirectCommandsStreamNV">
- <member><type>VkBuffer</type> <name>buffer</name></member>
- <member><type>VkDeviceSize</type> <name>offset</name></member>
- </type>
- <type category="struct" name="VkIndirectCommandsLayoutTokenNV">
- <member values="VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkIndirectCommandsTokenTypeNV</type> <name>tokenType</name></member>
- <member><type>uint32_t</type> <name>stream</name></member>
- <member><type>uint32_t</type> <name>offset</name></member>
- <member><type>uint32_t</type> <name>vertexBindingUnit</name></member>
- <member><type>VkBool32</type> <name>vertexDynamicStride</name></member>
- <member optional="true"><type>VkPipelineLayout</type> <name>pushconstantPipelineLayout</name></member>
- <member optional="true"><type>VkShaderStageFlags</type> <name>pushconstantShaderStageFlags</name></member>
- <member><type>uint32_t</type> <name>pushconstantOffset</name></member>
- <member><type>uint32_t</type> <name>pushconstantSize</name></member>
- <member optional="true"><type>VkIndirectStateFlagsNV</type> <name>indirectStateFlags</name></member>
- <member optional="true"><type>uint32_t</type> <name>indexTypeCount</name></member>
- <member len="indexTypeCount">const <type>VkIndexType</type>* <name>pIndexTypes</name></member>
- <member len="indexTypeCount">const <type>uint32_t</type>* <name>pIndexTypeValues</name></member>
- </type>
- <type category="struct" name="VkIndirectCommandsLayoutCreateInfoNV">
- <member values="VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkIndirectCommandsLayoutUsageFlagsNV</type> <name>flags</name></member>
- <member><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></member>
- <member><type>uint32_t</type> <name>tokenCount</name></member>
- <member len="tokenCount">const <type>VkIndirectCommandsLayoutTokenNV</type>* <name>pTokens</name></member>
- <member><type>uint32_t</type> <name>streamCount</name></member>
- <member len="streamCount">const <type>uint32_t</type>* <name>pStreamStrides</name></member>
- </type>
- <type category="struct" name="VkGeneratedCommandsInfoNV">
- <member values="VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></member>
- <member><type>VkPipeline</type> <name>pipeline</name></member>
- <member><type>VkIndirectCommandsLayoutNV</type> <name>indirectCommandsLayout</name></member>
- <member><type>uint32_t</type> <name>streamCount</name></member>
- <member len="streamCount">const <type>VkIndirectCommandsStreamNV</type>* <name>pStreams</name></member>
- <member><type>uint32_t</type> <name>sequencesCount</name></member>
- <member><type>VkBuffer</type> <name>preprocessBuffer</name></member>
- <member><type>VkDeviceSize</type> <name>preprocessOffset</name></member>
- <member><type>VkDeviceSize</type> <name>preprocessSize</name></member>
- <member optional="true"><type>VkBuffer</type> <name>sequencesCountBuffer</name></member>
- <member><type>VkDeviceSize</type> <name>sequencesCountOffset</name></member>
- <member optional="true"><type>VkBuffer</type> <name>sequencesIndexBuffer</name></member>
- <member><type>VkDeviceSize</type> <name>sequencesIndexOffset</name></member>
- </type>
- <type category="struct" name="VkGeneratedCommandsMemoryRequirementsInfoNV">
- <member values="VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></member>
- <member><type>VkPipeline</type> <name>pipeline</name></member>
- <member><type>VkIndirectCommandsLayoutNV</type> <name>indirectCommandsLayout</name></member>
- <member><type>uint32_t</type> <name>maxSequencesCount</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFeatures2" structextends="VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkPhysicalDeviceFeatures</type> <name>features</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFeatures2KHR" alias="VkPhysicalDeviceFeatures2"/>
- <type category="struct" name="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="struct"><type>VkPhysicalDeviceProperties</type> <name>properties</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceProperties2KHR" alias="VkPhysicalDeviceProperties2"/>
- <type category="struct" name="VkFormatProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkFormatProperties</type> <name>formatProperties</name></member>
- </type>
- <type category="struct" name="VkFormatProperties2KHR" alias="VkFormatProperties2"/>
- <type category="struct" name="VkImageFormatProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkImageFormatProperties</type> <name>imageFormatProperties</name></member>
- </type>
- <type category="struct" name="VkImageFormatProperties2KHR" alias="VkImageFormatProperties2"/>
- <type category="struct" name="VkPhysicalDeviceImageFormatInfo2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkImageType</type> <name>type</name></member>
- <member><type>VkImageTiling</type> <name>tiling</name></member>
- <member><type>VkImageUsageFlags</type> <name>usage</name></member>
- <member optional="true"><type>VkImageCreateFlags</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceImageFormatInfo2KHR" alias="VkPhysicalDeviceImageFormatInfo2"/>
- <type category="struct" name="VkQueueFamilyProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkQueueFamilyProperties</type> <name>queueFamilyProperties</name></member>
- </type>
- <type category="struct" name="VkQueueFamilyProperties2KHR" alias="VkQueueFamilyProperties2"/>
- <type category="struct" name="VkPhysicalDeviceMemoryProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkPhysicalDeviceMemoryProperties</type> <name>memoryProperties</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMemoryProperties2KHR" alias="VkPhysicalDeviceMemoryProperties2"/>
- <type category="struct" name="VkSparseImageFormatProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkSparseImageFormatProperties</type> <name>properties</name></member>
- </type>
- <type category="struct" name="VkSparseImageFormatProperties2KHR" alias="VkSparseImageFormatProperties2"/>
- <type category="struct" name="VkPhysicalDeviceSparseImageFormatInfo2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkImageType</type> <name>type</name></member>
- <member><type>VkSampleCountFlagBits</type> <name>samples</name></member>
- <member><type>VkImageUsageFlags</type> <name>usage</name></member>
- <member><type>VkImageTiling</type> <name>tiling</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSparseImageFormatInfo2KHR" alias="VkPhysicalDeviceSparseImageFormatInfo2"/>
- <type category="struct" name="VkPhysicalDevicePushDescriptorPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPushDescriptors</name></member>
- </type>
- <type category="struct" name="VkConformanceVersion">
- <member><type>uint8_t</type> <name>major</name></member>
- <member><type>uint8_t</type> <name>minor</name></member>
- <member><type>uint8_t</type> <name>subminor</name></member>
- <member><type>uint8_t</type> <name>patch</name></member>
- </type>
- <type category="struct" name="VkConformanceVersionKHR" alias="VkConformanceVersion"/>
- <type category="struct" name="VkPhysicalDeviceDriverProperties" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkDriverId</type> <name>driverID</name></member>
- <member limittype="noauto"><type>char</type> <name>driverName</name>[<enum>VK_MAX_DRIVER_NAME_SIZE</enum>]</member>
- <member limittype="noauto"><type>char</type> <name>driverInfo</name>[<enum>VK_MAX_DRIVER_INFO_SIZE</enum>]</member>
- <member limittype="noauto"><type>VkConformanceVersion</type> <name>conformanceVersion</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDriverPropertiesKHR" alias="VkPhysicalDeviceDriverProperties"/>
- <type category="struct" name="VkPresentRegionsKHR" structextends="VkPresentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>swapchainCount</name><comment>Copy of VkPresentInfoKHR::swapchainCount</comment></member>
- <member len="swapchainCount" optional="true">const <type>VkPresentRegionKHR</type>* <name>pRegions</name><comment>The regions that have changed</comment></member>
- </type>
- <type category="struct" name="VkPresentRegionKHR">
- <member optional="true"><type>uint32_t</type> <name>rectangleCount</name><comment>Number of rectangles in pRectangles</comment></member>
- <member optional="true" len="rectangleCount">const <type>VkRectLayerKHR</type>* <name>pRectangles</name><comment>Array of rectangles that have changed in a swapchain's image(s)</comment></member>
- </type>
- <type category="struct" name="VkRectLayerKHR">
- <member><type>VkOffset2D</type> <name>offset</name><comment>upper-left corner of a rectangle that has not changed, in pixels of a presentation images</comment></member>
- <member noautovalidity="true"><type>VkExtent2D</type> <name>extent</name><comment>Dimensions of a rectangle that has not changed, in pixels of a presentation images</comment></member>
- <member><type>uint32_t</type> <name>layer</name><comment>Layer of a swapchain's image(s), for stereoscopic-3D images</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVariablePointersFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>variablePointersStorageBuffer</name></member>
- <member><type>VkBool32</type> <name>variablePointers</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVariablePointersFeaturesKHR" alias="VkPhysicalDeviceVariablePointersFeatures"/>
- <type category="struct" name="VkPhysicalDeviceVariablePointerFeaturesKHR" alias="VkPhysicalDeviceVariablePointersFeatures"/>
- <type category="struct" name="VkPhysicalDeviceVariablePointerFeatures" alias="VkPhysicalDeviceVariablePointersFeatures"/>
- <type category="struct" name="VkExternalMemoryProperties" returnedonly="true">
- <member><type>VkExternalMemoryFeatureFlags</type> <name>externalMemoryFeatures</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlags</type> <name>exportFromImportedHandleTypes</name></member>
- <member><type>VkExternalMemoryHandleTypeFlags</type> <name>compatibleHandleTypes</name></member>
- </type>
- <type category="struct" name="VkExternalMemoryPropertiesKHR" alias="VkExternalMemoryProperties"/>
- <type category="struct" name="VkPhysicalDeviceExternalImageFormatInfo" structextends="VkPhysicalDeviceImageFormatInfo2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalImageFormatInfoKHR" alias="VkPhysicalDeviceExternalImageFormatInfo"/>
- <type category="struct" name="VkExternalImageFormatProperties" returnedonly="true" structextends="VkImageFormatProperties2">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkExternalMemoryProperties</type> <name>externalMemoryProperties</name></member>
- </type>
- <type category="struct" name="VkExternalImageFormatPropertiesKHR" alias="VkExternalImageFormatProperties"/>
- <type category="struct" name="VkPhysicalDeviceExternalBufferInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkBufferCreateFlags</type> <name>flags</name></member>
- <member><type>VkBufferUsageFlags</type> <name>usage</name></member>
- <member><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalBufferInfoKHR" alias="VkPhysicalDeviceExternalBufferInfo"/>
- <type category="struct" name="VkExternalBufferProperties" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkExternalMemoryProperties</type> <name>externalMemoryProperties</name></member>
- </type>
- <type category="struct" name="VkExternalBufferPropertiesKHR" alias="VkExternalBufferProperties"/>
- <type category="struct" name="VkPhysicalDeviceIDProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint8_t</type> <name>deviceUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
- <member limittype="noauto"><type>uint8_t</type> <name>driverUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
- <member limittype="noauto"><type>uint8_t</type> <name>deviceLUID</name>[<enum>VK_LUID_SIZE</enum>]</member>
- <member limittype="noauto"><type>uint32_t</type> <name>deviceNodeMask</name></member>
- <member limittype="noauto"><type>VkBool32</type> <name>deviceLUIDValid</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceIDPropertiesKHR" alias="VkPhysicalDeviceIDProperties"/>
- <type category="struct" name="VkExternalMemoryImageCreateInfo" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlags</type> <name>handleTypes</name></member>
- </type>
- <type category="struct" name="VkExternalMemoryImageCreateInfoKHR" alias="VkExternalMemoryImageCreateInfo"/>
- <type category="struct" name="VkExternalMemoryBufferCreateInfo" structextends="VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlags</type> <name>handleTypes</name></member>
- </type>
- <type category="struct" name="VkExternalMemoryBufferCreateInfoKHR" alias="VkExternalMemoryBufferCreateInfo"/>
- <type category="struct" name="VkExportMemoryAllocateInfo" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlags</type> <name>handleTypes</name></member>
- </type>
- <type category="struct" name="VkExportMemoryAllocateInfoKHR" alias="VkExportMemoryAllocateInfo"/>
- <type category="struct" name="VkImportMemoryWin32HandleInfoKHR" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- <member optional="true"><type>HANDLE</type> <name>handle</name></member>
- <member optional="true"><type>LPCWSTR</type> <name>name</name></member>
- </type>
- <type category="struct" name="VkExportMemoryWin32HandleInfoKHR" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true">const <type>SECURITY_ATTRIBUTES</type>* <name>pAttributes</name></member>
- <member><type>DWORD</type> <name>dwAccess</name></member>
- <member><type>LPCWSTR</type> <name>name</name></member>
- </type>
- <type category="struct" name="VkImportMemoryZirconHandleInfoFUCHSIA" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- <member optional="true"><type>zx_handle_t</type> <name>handle</name></member>
- </type>
- <type category="struct" name="VkMemoryZirconHandlePropertiesFUCHSIA" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>memoryTypeBits</name></member>
- </type>
- <type category="struct" name="VkMemoryGetZirconHandleInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceMemory</type> <name>memory</name></member>
- <member><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkMemoryWin32HandlePropertiesKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member devicememorytypebits="1"><type>uint32_t</type> <name>memoryTypeBits</name></member>
- </type>
- <type category="struct" name="VkMemoryGetWin32HandleInfoKHR">
- <member values="VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- <member><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkImportMemoryFdInfoKHR" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- <member><type>int</type> <name>fd</name></member>
- </type>
- <type category="struct" name="VkMemoryFdPropertiesKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member devicememorytypebits="1"><type>uint32_t</type> <name>memoryTypeBits</name></member>
- </type>
- <type category="struct" name="VkMemoryGetFdInfoKHR">
- <member values="VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- <member><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkWin32KeyedMutexAcquireReleaseInfoKHR" structextends="VkSubmitInfo,VkSubmitInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>acquireCount</name></member>
- <member len="acquireCount" devicememoryhandle="1">const <type>VkDeviceMemory</type>* <name>pAcquireSyncs</name></member>
- <member len="acquireCount">const <type>uint64_t</type>* <name>pAcquireKeys</name></member>
- <member len="acquireCount">const <type>uint32_t</type>* <name>pAcquireTimeouts</name></member>
- <member optional="true"><type>uint32_t</type> <name>releaseCount</name></member>
- <member len="releaseCount" devicememoryhandle="1">const <type>VkDeviceMemory</type>* <name>pReleaseSyncs</name></member>
- <member len="releaseCount">const <type>uint64_t</type>* <name>pReleaseKeys</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalSemaphoreInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalSemaphoreInfoKHR" alias="VkPhysicalDeviceExternalSemaphoreInfo"/>
- <type category="struct" name="VkExternalSemaphoreProperties" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlags</type> <name>exportFromImportedHandleTypes</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlags</type> <name>compatibleHandleTypes</name></member>
- <member optional="true"><type>VkExternalSemaphoreFeatureFlags</type> <name>externalSemaphoreFeatures</name></member>
- </type>
- <type category="struct" name="VkExternalSemaphorePropertiesKHR" alias="VkExternalSemaphoreProperties"/>
- <type category="struct" name="VkExportSemaphoreCreateInfo" structextends="VkSemaphoreCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalSemaphoreHandleTypeFlags</type> <name>handleTypes</name></member>
- </type>
- <type category="struct" name="VkExportSemaphoreCreateInfoKHR" alias="VkExportSemaphoreCreateInfo"/>
- <type category="struct" name="VkImportSemaphoreWin32HandleInfoKHR">
- <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member>
- <member optional="true"><type>VkSemaphoreImportFlags</type> <name>flags</name></member>
- <member noautovalidity="true"><type>VkExternalSemaphoreHandleTypeFlagBits</type> <name>handleType</name></member>
- <member optional="true"><type>HANDLE</type> <name>handle</name></member>
- <member optional="true"><type>LPCWSTR</type> <name>name</name></member>
- </type>
- <type category="struct" name="VkExportSemaphoreWin32HandleInfoKHR" structextends="VkSemaphoreCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true">const <type>SECURITY_ATTRIBUTES</type>* <name>pAttributes</name></member>
- <member><type>DWORD</type> <name>dwAccess</name></member>
- <member><type>LPCWSTR</type> <name>name</name></member>
- </type>
- <type category="struct" name="VkD3D12FenceSubmitInfoKHR" structextends="VkSubmitInfo">
- <member values="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>waitSemaphoreValuesCount</name></member>
- <member optional="true" len="waitSemaphoreValuesCount">const <type>uint64_t</type>* <name>pWaitSemaphoreValues</name></member>
- <member optional="true"><type>uint32_t</type> <name>signalSemaphoreValuesCount</name></member>
- <member optional="true" len="signalSemaphoreValuesCount">const <type>uint64_t</type>* <name>pSignalSemaphoreValues</name></member>
- </type>
- <type category="struct" name="VkSemaphoreGetWin32HandleInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSemaphore</type> <name>semaphore</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkImportSemaphoreFdInfoKHR">
- <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member>
- <member optional="true"><type>VkSemaphoreImportFlags</type> <name>flags</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlagBits</type> <name>handleType</name></member>
- <member><type>int</type> <name>fd</name></member>
- </type>
- <type category="struct" name="VkSemaphoreGetFdInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSemaphore</type> <name>semaphore</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkImportSemaphoreZirconHandleInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member>
- <member optional="true"><type>VkSemaphoreImportFlags</type> <name>flags</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlagBits</type> <name>handleType</name></member>
- <member><type>zx_handle_t</type> <name>zirconHandle</name></member>
- </type>
- <type category="struct" name="VkSemaphoreGetZirconHandleInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSemaphore</type> <name>semaphore</name></member>
- <member><type>VkExternalSemaphoreHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalFenceInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkExternalFenceHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalFenceInfoKHR" alias="VkPhysicalDeviceExternalFenceInfo"/>
- <type category="struct" name="VkExternalFenceProperties" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkExternalFenceHandleTypeFlags</type> <name>exportFromImportedHandleTypes</name></member>
- <member><type>VkExternalFenceHandleTypeFlags</type> <name>compatibleHandleTypes</name></member>
- <member optional="true"><type>VkExternalFenceFeatureFlags</type> <name>externalFenceFeatures</name></member>
- </type>
- <type category="struct" name="VkExternalFencePropertiesKHR" alias="VkExternalFenceProperties"/>
- <type category="struct" name="VkExportFenceCreateInfo" structextends="VkFenceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkExternalFenceHandleTypeFlags</type> <name>handleTypes</name></member>
- </type>
- <type category="struct" name="VkExportFenceCreateInfoKHR" alias="VkExportFenceCreateInfo"/>
- <type category="struct" name="VkImportFenceWin32HandleInfoKHR">
- <member values="VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkFence</type> <name>fence</name></member>
- <member optional="true"><type>VkFenceImportFlags</type> <name>flags</name></member>
- <member noautovalidity="true"><type>VkExternalFenceHandleTypeFlagBits</type> <name>handleType</name></member>
- <member optional="true"><type>HANDLE</type> <name>handle</name></member>
- <member optional="true"><type>LPCWSTR</type> <name>name</name></member>
- </type>
- <type category="struct" name="VkExportFenceWin32HandleInfoKHR" structextends="VkFenceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true">const <type>SECURITY_ATTRIBUTES</type>* <name>pAttributes</name></member>
- <member><type>DWORD</type> <name>dwAccess</name></member>
- <member><type>LPCWSTR</type> <name>name</name></member>
- </type>
- <type category="struct" name="VkFenceGetWin32HandleInfoKHR">
- <member values="VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFence</type> <name>fence</name></member>
- <member><type>VkExternalFenceHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkImportFenceFdInfoKHR">
- <member values="VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkFence</type> <name>fence</name></member>
- <member optional="true"><type>VkFenceImportFlags</type> <name>flags</name></member>
- <member><type>VkExternalFenceHandleTypeFlagBits</type> <name>handleType</name></member>
- <member><type>int</type> <name>fd</name></member>
- </type>
- <type category="struct" name="VkFenceGetFdInfoKHR">
- <member values="VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFence</type> <name>fence</name></member>
- <member><type>VkExternalFenceHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMultiviewFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>multiview</name><comment>Multiple views in a renderpass</comment></member>
- <member><type>VkBool32</type> <name>multiviewGeometryShader</name><comment>Multiple views in a renderpass w/ geometry shader</comment></member>
- <member><type>VkBool32</type> <name>multiviewTessellationShader</name><comment>Multiple views in a renderpass w/ tessellation shader</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMultiviewFeaturesKHR" alias="VkPhysicalDeviceMultiviewFeatures"/>
- <type category="struct" name="VkPhysicalDeviceMultiviewProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMultiviewViewCount</name><comment>max number of views in a subpass</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMultiviewInstanceIndex</name><comment>max instance index for a draw in a multiview subpass</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMultiviewPropertiesKHR" alias="VkPhysicalDeviceMultiviewProperties"/>
- <type category="struct" name="VkRenderPassMultiviewCreateInfo" structextends="VkRenderPassCreateInfo">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>subpassCount</name></member>
- <member len="subpassCount">const <type>uint32_t</type>* <name>pViewMasks</name></member>
- <member optional="true"><type>uint32_t</type> <name>dependencyCount</name></member>
- <member len="dependencyCount">const <type>int32_t</type>* <name>pViewOffsets</name></member>
- <member optional="true"><type>uint32_t</type> <name>correlationMaskCount</name></member>
- <member len="correlationMaskCount">const <type>uint32_t</type>* <name>pCorrelationMasks</name></member>
- </type>
- <type category="struct" name="VkRenderPassMultiviewCreateInfoKHR" alias="VkRenderPassMultiviewCreateInfo"/>
- <type category="struct" name="VkSurfaceCapabilities2EXT" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>minImageCount</name><comment>Supported minimum number of images for the surface</comment></member>
- <member><type>uint32_t</type> <name>maxImageCount</name><comment>Supported maximum number of images for the surface, 0 for unlimited</comment></member>
- <member><type>VkExtent2D</type> <name>currentExtent</name><comment>Current image width and height for the surface, (0, 0) if undefined</comment></member>
- <member><type>VkExtent2D</type> <name>minImageExtent</name><comment>Supported minimum image width and height for the surface</comment></member>
- <member><type>VkExtent2D</type> <name>maxImageExtent</name><comment>Supported maximum image width and height for the surface</comment></member>
- <member><type>uint32_t</type> <name>maxImageArrayLayers</name><comment>Supported maximum number of image layers for the surface</comment></member>
- <member><type>VkSurfaceTransformFlagsKHR</type> <name>supportedTransforms</name><comment>1 or more bits representing the transforms supported</comment></member>
- <member><type>VkSurfaceTransformFlagBitsKHR</type> <name>currentTransform</name><comment>The surface's current transform relative to the device's natural orientation</comment></member>
- <member><type>VkCompositeAlphaFlagsKHR</type> <name>supportedCompositeAlpha</name><comment>1 or more bits representing the alpha compositing modes supported</comment></member>
- <member><type>VkImageUsageFlags</type> <name>supportedUsageFlags</name><comment>Supported image usage flags for the surface</comment></member>
- <member optional="true"><type>VkSurfaceCounterFlagsEXT</type> <name>supportedSurfaceCounters</name></member>
- </type>
- <type category="struct" name="VkDisplayPowerInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDisplayPowerStateEXT</type> <name>powerState</name></member>
- </type>
- <type category="struct" name="VkDeviceEventInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceEventTypeEXT</type> <name>deviceEvent</name></member>
- </type>
- <type category="struct" name="VkDisplayEventInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDisplayEventTypeEXT</type> <name>displayEvent</name></member>
- </type>
- <type category="struct" name="VkSwapchainCounterCreateInfoEXT" structextends="VkSwapchainCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSurfaceCounterFlagsEXT</type> <name>surfaceCounters</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceGroupProperties" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>physicalDeviceCount</name></member>
- <member><type>VkPhysicalDevice</type> <name>physicalDevices</name>[<enum>VK_MAX_DEVICE_GROUP_SIZE</enum>]</member>
- <member><type>VkBool32</type> <name>subsetAllocation</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceGroupPropertiesKHR" alias="VkPhysicalDeviceGroupProperties"/>
- <type category="struct" name="VkMemoryAllocateFlagsInfo" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkMemoryAllocateFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>deviceMask</name></member>
- </type>
- <type category="struct" name="VkMemoryAllocateFlagsInfoKHR" alias="VkMemoryAllocateFlagsInfo"/>
- <type category="struct" name="VkBindBufferMemoryInfo">
- <member values="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBuffer</type> <name>buffer</name></member>
- <member devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- <member devicememoryoffset="1"><type>VkDeviceSize</type> <name>memoryOffset</name></member>
- </type>
- <type category="struct" name="VkBindBufferMemoryInfoKHR" alias="VkBindBufferMemoryInfo"/>
- <type category="struct" name="VkBindBufferMemoryDeviceGroupInfo" structextends="VkBindBufferMemoryInfo">
- <member values="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>deviceIndexCount</name></member>
- <member len="deviceIndexCount">const <type>uint32_t</type>* <name>pDeviceIndices</name></member>
- </type>
- <type category="struct" name="VkBindBufferMemoryDeviceGroupInfoKHR" alias="VkBindBufferMemoryDeviceGroupInfo"/>
- <type category="struct" name="VkBindImageMemoryInfo">
- <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImage</type> <name>image</name></member>
- <member noautovalidity="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- <member devicememoryoffset="1"><type>VkDeviceSize</type> <name>memoryOffset</name></member>
- </type>
- <type category="struct" name="VkBindImageMemoryInfoKHR" alias="VkBindImageMemoryInfo"/>
- <type category="struct" name="VkBindImageMemoryDeviceGroupInfo" structextends="VkBindImageMemoryInfo">
- <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>deviceIndexCount</name></member>
- <member len="deviceIndexCount">const <type>uint32_t</type>* <name>pDeviceIndices</name></member>
- <member optional="true"><type>uint32_t</type> <name>splitInstanceBindRegionCount</name></member>
- <member len="splitInstanceBindRegionCount">const <type>VkRect2D</type>* <name>pSplitInstanceBindRegions</name></member>
- </type>
- <type category="struct" name="VkBindImageMemoryDeviceGroupInfoKHR" alias="VkBindImageMemoryDeviceGroupInfo"/>
- <type category="struct" name="VkDeviceGroupRenderPassBeginInfo" structextends="VkRenderPassBeginInfo,VkRenderingInfoKHR">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>deviceMask</name></member>
- <member optional="true"><type>uint32_t</type> <name>deviceRenderAreaCount</name></member>
- <member len="deviceRenderAreaCount">const <type>VkRect2D</type>* <name>pDeviceRenderAreas</name></member>
- </type>
- <type category="struct" name="VkDeviceGroupRenderPassBeginInfoKHR" alias="VkDeviceGroupRenderPassBeginInfo"/>
- <type category="struct" name="VkDeviceGroupCommandBufferBeginInfo" structextends="VkCommandBufferBeginInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>deviceMask</name></member>
- </type>
- <type category="struct" name="VkDeviceGroupCommandBufferBeginInfoKHR" alias="VkDeviceGroupCommandBufferBeginInfo"/>
- <type category="struct" name="VkDeviceGroupSubmitInfo" structextends="VkSubmitInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></member>
- <member len="waitSemaphoreCount">const <type>uint32_t</type>* <name>pWaitSemaphoreDeviceIndices</name></member>
- <member optional="true"><type>uint32_t</type> <name>commandBufferCount</name></member>
- <member len="commandBufferCount">const <type>uint32_t</type>* <name>pCommandBufferDeviceMasks</name></member>
- <member optional="true"><type>uint32_t</type> <name>signalSemaphoreCount</name></member>
- <member len="signalSemaphoreCount">const <type>uint32_t</type>* <name>pSignalSemaphoreDeviceIndices</name></member>
- </type>
- <type category="struct" name="VkDeviceGroupSubmitInfoKHR" alias="VkDeviceGroupSubmitInfo"/>
- <type category="struct" name="VkDeviceGroupBindSparseInfo" structextends="VkBindSparseInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>resourceDeviceIndex</name></member>
- <member><type>uint32_t</type> <name>memoryDeviceIndex</name></member>
- </type>
- <type category="struct" name="VkDeviceGroupBindSparseInfoKHR" alias="VkDeviceGroupBindSparseInfo"/>
- <type category="struct" name="VkDeviceGroupPresentCapabilitiesKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>presentMask</name>[<enum>VK_MAX_DEVICE_GROUP_SIZE</enum>]</member>
- <member><type>VkDeviceGroupPresentModeFlagsKHR</type> <name>modes</name></member>
- </type>
- <type category="struct" name="VkImageSwapchainCreateInfoKHR" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member>
- </type>
- <type category="struct" name="VkBindImageMemorySwapchainInfoKHR" structextends="VkBindImageMemoryInfo">
- <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member>
- <member><type>uint32_t</type> <name>imageIndex</name></member>
- </type>
- <type category="struct" name="VkAcquireNextImageInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member>
- <member><type>uint64_t</type> <name>timeout</name></member>
- <member optional="true" externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member>
- <member optional="true" externsync="true"><type>VkFence</type> <name>fence</name></member>
- <member><type>uint32_t</type> <name>deviceMask</name></member>
- </type>
- <type category="struct" name="VkDeviceGroupPresentInfoKHR" structextends="VkPresentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>swapchainCount</name></member>
- <member len="swapchainCount">const <type>uint32_t</type>* <name>pDeviceMasks</name></member>
- <member><type>VkDeviceGroupPresentModeFlagBitsKHR</type> <name>mode</name></member>
- </type>
- <type category="struct" name="VkDeviceGroupDeviceCreateInfo" structextends="VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>physicalDeviceCount</name></member>
- <member len="physicalDeviceCount">const <type>VkPhysicalDevice</type>* <name>pPhysicalDevices</name></member>
- </type>
- <type category="struct" name="VkDeviceGroupDeviceCreateInfoKHR" alias="VkDeviceGroupDeviceCreateInfo"/>
- <type category="struct" name="VkDeviceGroupSwapchainCreateInfoKHR" structextends="VkSwapchainCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceGroupPresentModeFlagsKHR</type> <name>modes</name></member>
- </type>
- <type category="struct" name="VkDescriptorUpdateTemplateEntry">
- <member><type>uint32_t</type> <name>dstBinding</name><comment>Binding within the destination descriptor set to write</comment></member>
- <member><type>uint32_t</type> <name>dstArrayElement</name><comment>Array element within the destination binding to write</comment></member>
- <member><type>uint32_t</type> <name>descriptorCount</name><comment>Number of descriptors to write</comment></member>
- <member><type>VkDescriptorType</type> <name>descriptorType</name><comment>Descriptor type to write</comment></member>
- <member><type>size_t</type> <name>offset</name><comment>Offset into pData where the descriptors to update are stored</comment></member>
- <member><type>size_t</type> <name>stride</name><comment>Stride between two descriptors in pData when writing more than one descriptor</comment></member>
- </type>
- <type category="struct" name="VkDescriptorUpdateTemplateEntryKHR" alias="VkDescriptorUpdateTemplateEntry"/>
- <type category="struct" name="VkDescriptorUpdateTemplateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDescriptorUpdateTemplateCreateFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>descriptorUpdateEntryCount</name><comment>Number of descriptor update entries to use for the update template</comment></member>
- <member len="descriptorUpdateEntryCount">const <type>VkDescriptorUpdateTemplateEntry</type>* <name>pDescriptorUpdateEntries</name><comment>Descriptor update entries for the template</comment></member>
- <member><type>VkDescriptorUpdateTemplateType</type> <name>templateType</name></member>
- <member noautovalidity="true"><type>VkDescriptorSetLayout</type> <name>descriptorSetLayout</name></member>
- <member noautovalidity="true"><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></member>
- <member noautovalidity="true"><type>VkPipelineLayout</type><name>pipelineLayout</name><comment>If used for push descriptors, this is the only allowed layout</comment></member>
- <member noautovalidity="true"><type>uint32_t</type> <name>set</name></member>
- </type>
- <type category="struct" name="VkDescriptorUpdateTemplateCreateInfoKHR" alias="VkDescriptorUpdateTemplateCreateInfo"/>
- <type category="struct" name="VkXYColorEXT" comment="Chromaticity coordinate">
- <member><type>float</type> <name>x</name></member>
- <member><type>float</type> <name>y</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePresentIdFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>presentId</name><comment>Present ID in VkPresentInfoKHR</comment></member>
- </type>
- <type category="struct" name="VkPresentIdKHR" structextends="VkPresentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PRESENT_ID_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>swapchainCount</name><comment>Copy of VkPresentInfoKHR::swapchainCount</comment></member>
- <member len="swapchainCount" optional="true">const <type>uint64_t</type>* <name>pPresentIds</name><comment>Present ID values for each swapchain</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePresentWaitFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>presentWait</name><comment>vkWaitForPresentKHR is supported</comment></member>
- </type>
- <type category="struct" name="VkHdrMetadataEXT">
- <comment>Display primary in chromaticity coordinates</comment>
- <member values="VK_STRUCTURE_TYPE_HDR_METADATA_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <comment> From SMPTE 2086</comment>
- <member noautovalidity="true"><type>VkXYColorEXT</type> <name>displayPrimaryRed</name><comment>Display primary's Red</comment></member>
- <member noautovalidity="true"><type>VkXYColorEXT</type> <name>displayPrimaryGreen</name><comment>Display primary's Green</comment></member>
- <member noautovalidity="true"><type>VkXYColorEXT</type> <name>displayPrimaryBlue</name><comment>Display primary's Blue</comment></member>
- <member noautovalidity="true"><type>VkXYColorEXT</type> <name>whitePoint</name><comment>Display primary's Blue</comment></member>
- <member noautovalidity="true"><type>float</type> <name>maxLuminance</name><comment>Display maximum luminance</comment></member>
- <member noautovalidity="true"><type>float</type> <name>minLuminance</name><comment>Display minimum luminance</comment></member>
- <comment> From CTA 861.3</comment>
- <member noautovalidity="true"><type>float</type> <name>maxContentLightLevel</name><comment>Content maximum luminance</comment></member>
- <member noautovalidity="true"><type>float</type> <name>maxFrameAverageLightLevel</name></member>
- </type>
- <type category="struct" name="VkDisplayNativeHdrSurfaceCapabilitiesAMD" returnedonly="true" structextends="VkSurfaceCapabilities2KHR">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>localDimmingSupport</name></member>
- </type>
- <type category="struct" name="VkSwapchainDisplayNativeHdrCreateInfoAMD" structextends="VkSwapchainCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>localDimmingEnable</name></member>
- </type>
- <type category="struct" name="VkRefreshCycleDurationGOOGLE" returnedonly="true">
- <member><type>uint64_t</type> <name>refreshDuration</name><comment>Number of nanoseconds from the start of one refresh cycle to the next</comment></member>
- </type>
- <type category="struct" name="VkPastPresentationTimingGOOGLE" returnedonly="true">
- <member><type>uint32_t</type> <name>presentID</name><comment>Application-provided identifier, previously given to vkQueuePresentKHR</comment></member>
- <member><type>uint64_t</type> <name>desiredPresentTime</name><comment>Earliest time an image should have been presented, previously given to vkQueuePresentKHR</comment></member>
- <member><type>uint64_t</type> <name>actualPresentTime</name><comment>Time the image was actually displayed</comment></member>
- <member><type>uint64_t</type> <name>earliestPresentTime</name><comment>Earliest time the image could have been displayed</comment></member>
- <member><type>uint64_t</type> <name>presentMargin</name><comment>How early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime</comment></member>
- </type>
- <type category="struct" name="VkPresentTimesInfoGOOGLE" structextends="VkPresentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>swapchainCount</name><comment>Copy of VkPresentInfoKHR::swapchainCount</comment></member>
- <member len="swapchainCount" optional="true">const <type>VkPresentTimeGOOGLE</type>* <name>pTimes</name><comment>The earliest times to present images</comment></member>
- </type>
- <type category="struct" name="VkPresentTimeGOOGLE">
- <member><type>uint32_t</type> <name>presentID</name><comment>Application-provided identifier</comment></member>
- <member><type>uint64_t</type> <name>desiredPresentTime</name><comment>Earliest time an image should be presented</comment></member>
- </type>
- <type category="struct" name="VkIOSSurfaceCreateInfoMVK">
- <member values="VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkIOSSurfaceCreateFlagsMVK</type> <name>flags</name></member>
- <member noautovalidity="true">const <type>void</type>* <name>pView</name></member>
- </type>
- <type category="struct" name="VkMacOSSurfaceCreateInfoMVK">
- <member values="VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkMacOSSurfaceCreateFlagsMVK</type> <name>flags</name></member>
- <member noautovalidity="true">const <type>void</type>* <name>pView</name></member>
- </type>
- <type category="struct" name="VkMetalSurfaceCreateInfoEXT">
- <member values="VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkMetalSurfaceCreateFlagsEXT</type> <name>flags</name></member>
- <member noautovalidity="true">const <type>CAMetalLayer</type>* <name>pLayer</name></member>
- </type>
- <type category="struct" name="VkViewportWScalingNV">
- <member><type>float</type> <name>xcoeff</name></member>
- <member><type>float</type> <name>ycoeff</name></member>
- </type>
- <type category="struct" name="VkPipelineViewportWScalingStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>viewportWScalingEnable</name></member>
- <member><type>uint32_t</type> <name>viewportCount</name></member>
- <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></member>
- </type>
- <type category="struct" name="VkViewportSwizzleNV">
- <member><type>VkViewportCoordinateSwizzleNV</type> <name>x</name></member>
- <member><type>VkViewportCoordinateSwizzleNV</type> <name>y</name></member>
- <member><type>VkViewportCoordinateSwizzleNV</type> <name>z</name></member>
- <member><type>VkViewportCoordinateSwizzleNV</type> <name>w</name></member>
- </type>
- <type category="struct" name="VkPipelineViewportSwizzleStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineViewportSwizzleStateCreateFlagsNV</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>viewportCount</name></member>
- <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewportSwizzleNV</type>* <name>pViewportSwizzles</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDiscardRectanglePropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDiscardRectangles</name><comment>max number of active discard rectangles</comment></member>
- </type>
- <type category="struct" name="VkPipelineDiscardRectangleStateCreateInfoEXT" structextends="VkGraphicsPipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineDiscardRectangleStateCreateFlagsEXT</type> <name>flags</name></member>
- <member><type>VkDiscardRectangleModeEXT</type> <name>discardRectangleMode</name></member>
- <member optional="true"><type>uint32_t</type> <name>discardRectangleCount</name></member>
- <member noautovalidity="true" len="discardRectangleCount">const <type>VkRect2D</type>* <name>pDiscardRectangles</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>perViewPositionAllComponents</name></member>
- </type>
- <type category="struct" name="VkInputAttachmentAspectReference">
- <member><type>uint32_t</type> <name>subpass</name></member>
- <member><type>uint32_t</type> <name>inputAttachmentIndex</name></member>
- <member><type>VkImageAspectFlags</type> <name>aspectMask</name></member>
- </type>
- <type category="struct" name="VkInputAttachmentAspectReferenceKHR" alias="VkInputAttachmentAspectReference"/>
- <type category="struct" name="VkRenderPassInputAttachmentAspectCreateInfo" structextends="VkRenderPassCreateInfo">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>aspectReferenceCount</name></member>
- <member len="aspectReferenceCount">const <type>VkInputAttachmentAspectReference</type>* <name>pAspectReferences</name></member>
- </type>
- <type category="struct" name="VkRenderPassInputAttachmentAspectCreateInfoKHR" alias="VkRenderPassInputAttachmentAspectCreateInfo"/>
- <type category="struct" name="VkPhysicalDeviceSurfaceInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSurfaceKHR</type> <name>surface</name></member>
- </type>
- <type category="struct" name="VkSurfaceCapabilities2KHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkSurfaceCapabilitiesKHR</type> <name>surfaceCapabilities</name></member>
- </type>
- <type category="struct" name="VkSurfaceFormat2KHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkSurfaceFormatKHR</type> <name>surfaceFormat</name></member>
- </type>
- <type category="struct" name="VkDisplayProperties2KHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDisplayPropertiesKHR</type> <name>displayProperties</name></member>
- </type>
- <type category="struct" name="VkDisplayPlaneProperties2KHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDisplayPlanePropertiesKHR</type> <name>displayPlaneProperties</name></member>
- </type>
- <type category="struct" name="VkDisplayModeProperties2KHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDisplayModePropertiesKHR</type> <name>displayModeProperties</name></member>
- </type>
- <type category="struct" name="VkDisplayPlaneInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member externsync="true"><type>VkDisplayModeKHR</type> <name>mode</name></member>
- <member><type>uint32_t</type> <name>planeIndex</name></member>
- </type>
- <type category="struct" name="VkDisplayPlaneCapabilities2KHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDisplayPlaneCapabilitiesKHR</type> <name>capabilities</name></member>
- </type>
- <type category="struct" name="VkSharedPresentSurfaceCapabilitiesKHR" returnedonly="true" structextends="VkSurfaceCapabilities2KHR">
- <member values="VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImageUsageFlags</type> <name>sharedPresentSupportedUsageFlags</name><comment>Supported image usage flags if swapchain created using a shared present mode</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDevice16BitStorageFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>storageBuffer16BitAccess</name><comment>16-bit integer/floating-point variables supported in BufferBlock</comment></member>
- <member><type>VkBool32</type> <name>uniformAndStorageBuffer16BitAccess</name><comment>16-bit integer/floating-point variables supported in BufferBlock and Block</comment></member>
- <member><type>VkBool32</type> <name>storagePushConstant16</name><comment>16-bit integer/floating-point variables supported in PushConstant</comment></member>
- <member><type>VkBool32</type> <name>storageInputOutput16</name><comment>16-bit integer/floating-point variables supported in shader inputs and outputs</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDevice16BitStorageFeaturesKHR" alias="VkPhysicalDevice16BitStorageFeatures"/>
- <type category="struct" name="VkPhysicalDeviceSubgroupProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto" noautovalidity="true"><type>uint32_t</type> <name>subgroupSize</name><comment>The size of a subgroup for this queue.</comment></member>
- <member limittype="bitmask" noautovalidity="true"><type>VkShaderStageFlags</type> <name>supportedStages</name><comment>Bitfield of what shader stages support subgroup operations</comment></member>
- <member limittype="bitmask" noautovalidity="true"><type>VkSubgroupFeatureFlags</type> <name>supportedOperations</name><comment>Bitfield of what subgroup operations are supported.</comment></member>
- <member limittype="bitmask" noautovalidity="true"><type>VkBool32</type> <name>quadOperationsInAllStages</name><comment>Flag to specify whether quad operations are available in all stages.</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkBool32</type> <name>shaderSubgroupExtendedTypes</name><comment>Flag to specify whether subgroup operations with extended types are supported</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR" alias="VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"/>
- <type category="struct" name="VkBufferMemoryRequirementsInfo2">
- <member values="VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBuffer</type> <name>buffer</name></member>
- </type>
- <type category="struct" name="VkBufferMemoryRequirementsInfo2KHR" alias="VkBufferMemoryRequirementsInfo2"/>
- <type category="struct" name="VkDeviceBufferMemoryRequirementsKHR">
- <member values="VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member>const <type>VkBufferCreateInfo</type>* <name>pCreateInfo</name></member>
- </type>
- <type category="struct" name="VkImageMemoryRequirementsInfo2">
- <member values="VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImage</type> <name>image</name></member>
- </type>
- <type category="struct" name="VkImageMemoryRequirementsInfo2KHR" alias="VkImageMemoryRequirementsInfo2"/>
- <type category="struct" name="VkImageSparseMemoryRequirementsInfo2">
- <member values="VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImage</type> <name>image</name></member>
- </type>
- <type category="struct" name="VkImageSparseMemoryRequirementsInfo2KHR" alias="VkImageSparseMemoryRequirementsInfo2"/>
- <type category="struct" name="VkDeviceImageMemoryRequirementsKHR">
- <member values="VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member>const <type>VkImageCreateInfo</type>* <name>pCreateInfo</name></member>
- <member><type>VkImageAspectFlagBits</type> <name>planeAspect</name></member>
- </type>
- <type category="struct" name="VkMemoryRequirements2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkMemoryRequirements</type> <name>memoryRequirements</name></member>
- </type>
- <type category="struct" name="VkMemoryRequirements2KHR" alias="VkMemoryRequirements2"/>
- <type category="struct" name="VkSparseImageMemoryRequirements2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkSparseImageMemoryRequirements</type> <name>memoryRequirements</name></member>
- </type>
- <type category="struct" name="VkSparseImageMemoryRequirements2KHR" alias="VkSparseImageMemoryRequirements2"/>
- <type category="struct" name="VkPhysicalDevicePointClippingProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkPointClippingBehavior</type> <name>pointClippingBehavior</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePointClippingPropertiesKHR" alias="VkPhysicalDevicePointClippingProperties"/>
- <type category="struct" name="VkMemoryDedicatedRequirements" returnedonly="true" structextends="VkMemoryRequirements2">
- <member values="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>prefersDedicatedAllocation</name></member>
- <member><type>VkBool32</type> <name>requiresDedicatedAllocation</name></member>
- </type>
- <type category="struct" name="VkMemoryDedicatedRequirementsKHR" alias="VkMemoryDedicatedRequirements"/>
- <type category="struct" name="VkMemoryDedicatedAllocateInfo" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImage</type> <name>image</name><comment>Image that this allocation will be bound to</comment></member>
- <member optional="true"><type>VkBuffer</type> <name>buffer</name><comment>Buffer that this allocation will be bound to</comment></member>
- </type>
- <type category="struct" name="VkMemoryDedicatedAllocateInfoKHR" alias="VkMemoryDedicatedAllocateInfo"/>
- <type category="struct" name="VkImageViewUsageCreateInfo" structextends="VkImageViewCreateInfo">
- <member values="VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageUsageFlags</type> <name>usage</name></member>
- </type>
- <type category="struct" name="VkImageViewUsageCreateInfoKHR" alias="VkImageViewUsageCreateInfo"/>
- <type category="struct" name="VkPipelineTessellationDomainOriginStateCreateInfo" structextends="VkPipelineTessellationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkTessellationDomainOrigin</type> <name>domainOrigin</name></member>
- </type>
- <type category="struct" name="VkPipelineTessellationDomainOriginStateCreateInfoKHR" alias="VkPipelineTessellationDomainOriginStateCreateInfo"/>
- <type category="struct" name="VkSamplerYcbcrConversionInfo" structextends="VkSamplerCreateInfo,VkImageViewCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSamplerYcbcrConversion</type> <name>conversion</name></member>
- </type>
- <type category="struct" name="VkSamplerYcbcrConversionInfoKHR" alias="VkSamplerYcbcrConversionInfo"/>
- <type category="struct" name="VkSamplerYcbcrConversionCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkSamplerYcbcrModelConversion</type> <name>ycbcrModel</name></member>
- <member><type>VkSamplerYcbcrRange</type> <name>ycbcrRange</name></member>
- <member><type>VkComponentMapping</type> <name>components</name></member>
- <member><type>VkChromaLocation</type> <name>xChromaOffset</name></member>
- <member><type>VkChromaLocation</type> <name>yChromaOffset</name></member>
- <member><type>VkFilter</type> <name>chromaFilter</name></member>
- <member><type>VkBool32</type> <name>forceExplicitReconstruction</name></member>
- </type>
- <type category="struct" name="VkSamplerYcbcrConversionCreateInfoKHR" alias="VkSamplerYcbcrConversionCreateInfo"/>
- <type category="struct" name="VkBindImagePlaneMemoryInfo" structextends="VkBindImageMemoryInfo">
- <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageAspectFlagBits</type> <name>planeAspect</name></member>
- </type>
- <type category="struct" name="VkBindImagePlaneMemoryInfoKHR" alias="VkBindImagePlaneMemoryInfo"/>
- <type category="struct" name="VkImagePlaneMemoryRequirementsInfo" structextends="VkImageMemoryRequirementsInfo2">
- <member values="VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageAspectFlagBits</type> <name>planeAspect</name></member>
- </type>
- <type category="struct" name="VkImagePlaneMemoryRequirementsInfoKHR" alias="VkImagePlaneMemoryRequirementsInfo"/>
- <type category="struct" name="VkPhysicalDeviceSamplerYcbcrConversionFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>samplerYcbcrConversion</name><comment>Sampler color conversion supported</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR" alias="VkPhysicalDeviceSamplerYcbcrConversionFeatures"/>
- <type category="struct" name="VkSamplerYcbcrConversionImageFormatProperties" returnedonly="true" structextends="VkImageFormatProperties2">
- <member values="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>combinedImageSamplerDescriptorCount</name></member>
- </type>
- <type category="struct" name="VkSamplerYcbcrConversionImageFormatPropertiesKHR" alias="VkSamplerYcbcrConversionImageFormatProperties"/>
- <type category="struct" name="VkTextureLODGatherFormatPropertiesAMD" returnedonly="true" structextends="VkImageFormatProperties2">
- <member values="VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>supportsTextureGatherLODBiasAMD</name></member>
- </type>
- <type category="struct" name="VkConditionalRenderingBeginInfoEXT">
- <member values="VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBuffer</type> <name>buffer</name></member>
- <member><type>VkDeviceSize</type> <name>offset</name></member>
- <member optional="true"><type>VkConditionalRenderingFlagsEXT</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkProtectedSubmitInfo" structextends="VkSubmitInfo">
- <member values="VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>protectedSubmit</name><comment>Submit protected command buffers</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceProtectedMemoryFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>protectedMemory</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceProtectedMemoryProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkBool32</type> <name>protectedNoFault</name></member>
- </type>
- <type category="struct" name="VkDeviceQueueInfo2">
- <member values="VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDeviceQueueCreateFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>queueFamilyIndex</name></member>
- <member><type>uint32_t</type> <name>queueIndex</name></member>
- </type>
- <type category="struct" name="VkPipelineCoverageToColorStateCreateInfoNV" structextends="VkPipelineMultisampleStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCoverageToColorStateCreateFlagsNV</type> <name>flags</name></member>
- <member><type>VkBool32</type> <name>coverageToColorEnable</name></member>
- <member optional="true"><type>uint32_t</type> <name>coverageToColorLocation</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSamplerFilterMinmaxProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>filterMinmaxSingleComponentFormats</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>filterMinmaxImageComponentMapping</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT" alias="VkPhysicalDeviceSamplerFilterMinmaxProperties"/>
- <type category="struct" name="VkSampleLocationEXT">
- <member><type>float</type> <name>x</name></member>
- <member><type>float</type> <name>y</name></member>
- </type>
- <type category="struct" name="VkSampleLocationsInfoEXT" structextends="VkImageMemoryBarrier,VkImageMemoryBarrier2KHR">
- <member values="VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkSampleCountFlagBits</type> <name>sampleLocationsPerPixel</name></member>
- <member><type>VkExtent2D</type> <name>sampleLocationGridSize</name></member>
- <member optional="true"><type>uint32_t</type> <name>sampleLocationsCount</name></member>
- <member len="sampleLocationsCount">const <type>VkSampleLocationEXT</type>* <name>pSampleLocations</name></member>
- </type>
- <type category="struct" name="VkAttachmentSampleLocationsEXT">
- <member><type>uint32_t</type> <name>attachmentIndex</name></member>
- <member><type>VkSampleLocationsInfoEXT</type> <name>sampleLocationsInfo</name></member>
- </type>
- <type category="struct" name="VkSubpassSampleLocationsEXT">
- <member><type>uint32_t</type> <name>subpassIndex</name></member>
- <member><type>VkSampleLocationsInfoEXT</type> <name>sampleLocationsInfo</name></member>
- </type>
- <type category="struct" name="VkRenderPassSampleLocationsBeginInfoEXT" structextends="VkRenderPassBeginInfo">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentInitialSampleLocationsCount</name></member>
- <member len="attachmentInitialSampleLocationsCount">const <type>VkAttachmentSampleLocationsEXT</type>* <name>pAttachmentInitialSampleLocations</name></member>
- <member optional="true"><type>uint32_t</type> <name>postSubpassSampleLocationsCount</name></member>
- <member len="postSubpassSampleLocationsCount">const <type>VkSubpassSampleLocationsEXT</type>* <name>pPostSubpassSampleLocations</name></member>
- </type>
- <type category="struct" name="VkPipelineSampleLocationsStateCreateInfoEXT" structextends="VkPipelineMultisampleStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>sampleLocationsEnable</name></member>
- <member><type>VkSampleLocationsInfoEXT</type> <name>sampleLocationsInfo</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSampleLocationsPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkSampleCountFlags</type> <name>sampleLocationSampleCounts</name></member>
- <member limittype="max"><type>VkExtent2D</type> <name>maxSampleLocationGridSize</name></member>
- <member limittype="range"><type>float</type> <name>sampleLocationCoordinateRange</name>[2]</member>
- <member limittype="noauto"><type>uint32_t</type> <name>sampleLocationSubPixelBits</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>variableSampleLocations</name></member>
- </type>
- <type category="struct" name="VkMultisamplePropertiesEXT" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkExtent2D</type> <name>maxSampleLocationGridSize</name></member>
- </type>
- <type category="struct" name="VkSamplerReductionModeCreateInfo" structextends="VkSamplerCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSamplerReductionMode</type> <name>reductionMode</name></member>
- </type>
- <type category="struct" name="VkSamplerReductionModeCreateInfoEXT" alias="VkSamplerReductionModeCreateInfo"/>
- <type category="struct" name="VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>advancedBlendCoherentOperations</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMultiDrawFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>multiDraw</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>advancedBlendMaxColorAttachments</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>advancedBlendIndependentBlend</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>advancedBlendNonPremultipliedSrcColor</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>advancedBlendNonPremultipliedDstColor</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>advancedBlendCorrelatedOverlap</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>advancedBlendAllOperations</name></member>
- </type>
- <type category="struct" name="VkPipelineColorBlendAdvancedStateCreateInfoEXT" structextends="VkPipelineColorBlendStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>srcPremultiplied</name></member>
- <member><type>VkBool32</type> <name>dstPremultiplied</name></member>
- <member><type>VkBlendOverlapEXT</type> <name>blendOverlap</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceInlineUniformBlockFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>inlineUniformBlock</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingInlineUniformBlockUpdateAfterBind</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceInlineUniformBlockPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxInlineUniformBlockSize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorInlineUniformBlocks</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetInlineUniformBlocks</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindInlineUniformBlocks</name></member>
- </type>
- <type category="struct" name="VkWriteDescriptorSetInlineUniformBlockEXT" structextends="VkWriteDescriptorSet">
- <member values="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>dataSize</name></member>
- <member len="dataSize">const <type>void</type>* <name>pData</name></member>
- </type>
- <type category="struct" name="VkDescriptorPoolInlineUniformBlockCreateInfoEXT" structextends="VkDescriptorPoolCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxInlineUniformBlockBindings</name></member>
- </type>
- <type category="struct" name="VkPipelineCoverageModulationStateCreateInfoNV" structextends="VkPipelineMultisampleStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCoverageModulationStateCreateFlagsNV</type> <name>flags</name></member>
- <member><type>VkCoverageModulationModeNV</type> <name>coverageModulationMode</name></member>
- <member><type>VkBool32</type> <name>coverageModulationTableEnable</name></member>
- <member optional="true"><type>uint32_t</type> <name>coverageModulationTableCount</name></member>
- <member noautovalidity="true" optional="true" len="coverageModulationTableCount">const <type>float</type>* <name>pCoverageModulationTable</name></member>
- </type>
- <type category="struct" name="VkImageFormatListCreateInfo" structextends="VkImageCreateInfo,VkSwapchainCreateInfoKHR,VkPhysicalDeviceImageFormatInfo2">
- <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>viewFormatCount</name></member>
- <member len="viewFormatCount">const <type>VkFormat</type>* <name>pViewFormats</name></member>
- </type>
- <type category="struct" name="VkImageFormatListCreateInfoKHR" alias="VkImageFormatListCreateInfo"/>
- <type category="struct" name="VkValidationCacheCreateInfoEXT">
- <member values="VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkValidationCacheCreateFlagsEXT</type> <name>flags</name></member>
- <member optional="true"><type>size_t</type> <name>initialDataSize</name></member>
- <member len="initialDataSize">const <type>void</type>* <name>pInitialData</name></member>
- </type>
- <type category="struct" name="VkShaderModuleValidationCacheCreateInfoEXT" structextends="VkShaderModuleCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkValidationCacheEXT</type> <name>validationCache</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMaintenance3Properties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerSetDescriptors</name></member>
- <member limittype="max"><type>VkDeviceSize</type> <name>maxMemoryAllocationSize</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMaintenance3PropertiesKHR" alias="VkPhysicalDeviceMaintenance3Properties"/>
- <type category="struct" name="VkPhysicalDeviceMaintenance4FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>maintenance4</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMaintenance4PropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>VkDeviceSize</type> <name>maxBufferSize</name></member>
- </type>
- <type category="struct" name="VkDescriptorSetLayoutSupport" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>supported</name></member>
- </type>
- <type category="struct" name="VkDescriptorSetLayoutSupportKHR" alias="VkDescriptorSetLayoutSupport"/>
- <type category="struct" name="VkPhysicalDeviceShaderDrawParametersFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderDrawParameters</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderDrawParameterFeatures" alias="VkPhysicalDeviceShaderDrawParametersFeatures"/>
- <type category="struct" name="VkPhysicalDeviceShaderFloat16Int8Features" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo" optional="streamFeature:VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderFloat16</name><comment>16-bit floats (halfs) in shaders</comment></member>
- <member><type>VkBool32</type> <name>shaderInt8</name><comment>8-bit integers in shaders</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderFloat16Int8FeaturesKHR" alias="VkPhysicalDeviceShaderFloat16Int8Features" optional="streamFeature:VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT"/>
- <type category="struct" name="VkPhysicalDeviceFloat16Int8FeaturesKHR" alias="VkPhysicalDeviceShaderFloat16Int8Features" optional="streamFeature:VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT"/>
- <type category="struct" name="VkPhysicalDeviceFloatControlsProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkShaderFloatControlsIndependence</type> <name>denormBehaviorIndependence</name></member>
- <member limittype="noauto"><type>VkShaderFloatControlsIndependence</type> <name>roundingModeIndependence</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat16</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat32</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat64</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormPreserveFloat16</name><comment>An implementation can preserve denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormPreserveFloat32</name><comment>An implementation can preserve denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormPreserveFloat64</name><comment>An implementation can preserve denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat16</name><comment>An implementation can flush to zero denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat32</name><comment>An implementation can flush to zero denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat64</name><comment>An implementation can flush to zero denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat16</name><comment>An implementation can support RTE</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat32</name><comment>An implementation can support RTE</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat64</name><comment>An implementation can support RTE</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat16</name><comment>An implementation can support RTZ</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat32</name><comment>An implementation can support RTZ</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat64</name><comment>An implementation can support RTZ</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFloatControlsPropertiesKHR" alias="VkPhysicalDeviceFloatControlsProperties"/>
- <type category="struct" name="VkPhysicalDeviceHostQueryResetFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>hostQueryReset</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceHostQueryResetFeaturesEXT" alias="VkPhysicalDeviceHostQueryResetFeatures"/>
- <type category="struct" name="VkNativeBufferANDROID" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member>const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true">const <type>uint32_t</type>* <name>handle</name></member>
- <member><type>int</type> <name>stride</name></member>
- <member><type>int</type> <name>format</name></member>
- <member><type>int</type> <name>usage</name></member>
- <member><type>uint64_t</type> <name>consumer</name></member>
- <member><type>uint64_t</type> <name>producer</name></member>
- </type>
- <type category="struct" name="VkShaderResourceUsageAMD" returnedonly="true">
- <member><type>uint32_t</type> <name>numUsedVgprs</name></member>
- <member><type>uint32_t</type> <name>numUsedSgprs</name></member>
- <member><type>uint32_t</type> <name>ldsSizePerLocalWorkGroup</name></member>
- <member><type>size_t</type> <name>ldsUsageSizeInBytes</name></member>
- <member><type>size_t</type> <name>scratchMemUsageInBytes</name></member>
- </type>
- <type category="struct" name="VkShaderStatisticsInfoAMD" returnedonly="true">
- <member><type>VkShaderStageFlags</type> <name>shaderStageMask</name></member>
- <member><type>VkShaderResourceUsageAMD</type> <name>resourceUsage</name></member>
- <member><type>uint32_t</type> <name>numPhysicalVgprs</name></member>
- <member><type>uint32_t</type> <name>numPhysicalSgprs</name></member>
- <member><type>uint32_t</type> <name>numAvailableVgprs</name></member>
- <member><type>uint32_t</type> <name>numAvailableSgprs</name></member>
- <member><type>uint32_t</type> <name>computeWorkGroupSize</name>[3]</member>
- </type>
- <type category="struct" name="VkDeviceQueueGlobalPriorityCreateInfoEXT" structextends="VkDeviceQueueCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkQueueGlobalPriorityEXT</type> <name>globalPriority</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>globalPriorityQuery</name></member>
- </type>
- <type category="struct" name="VkQueueFamilyGlobalPriorityPropertiesEXT" structextends="VkQueueFamilyProperties2">
- <member values="VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>priorityCount</name></member>
- <member><type>VkQueueGlobalPriorityEXT</type> <name>priorities</name>[<enum>VK_MAX_GLOBAL_PRIORITY_SIZE_EXT</enum>]</member>
- </type>
- <type category="struct" name="VkDebugUtilsObjectNameInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkObjectType</type> <name>objectType</name></member>
- <member objecttype="objectType"><type>uint64_t</type> <name>objectHandle</name></member>
- <member optional="true" len="null-terminated">const <type>char</type>* <name>pObjectName</name></member>
- </type>
- <type category="struct" name="VkDebugUtilsObjectTagInfoEXT">
- <member values="VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkObjectType</type> <name>objectType</name></member>
- <member objecttype="objectType"><type>uint64_t</type> <name>objectHandle</name></member>
- <member><type>uint64_t</type> <name>tagName</name></member>
- <member><type>size_t</type> <name>tagSize</name></member>
- <member len="tagSize">const <type>void</type>* <name>pTag</name></member>
- </type>
- <type category="struct" name="VkDebugUtilsLabelEXT">
- <member values="VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member len="null-terminated">const <type>char</type>* <name>pLabelName</name></member>
- <member><type>float</type> <name>color</name>[4]</member>
- </type>
- <type category="struct" name="VkDebugUtilsMessengerCreateInfoEXT" allowduplicate="true" structextends="VkInstanceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDebugUtilsMessengerCreateFlagsEXT</type> <name>flags</name></member>
- <member><type>VkDebugUtilsMessageSeverityFlagsEXT</type> <name>messageSeverity</name></member>
- <member><type>VkDebugUtilsMessageTypeFlagsEXT</type> <name>messageType</name></member>
- <member><type>PFN_vkDebugUtilsMessengerCallbackEXT</type> <name>pfnUserCallback</name></member>
- <member optional="true"><type>void</type>* <name>pUserData</name></member>
- </type>
- <type category="struct" name="VkDebugUtilsMessengerCallbackDataEXT">
- <member values="VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDebugUtilsMessengerCallbackDataFlagsEXT</type> <name>flags</name></member>
- <member optional="true" len="null-terminated">const <type>char</type>* <name>pMessageIdName</name></member>
- <member><type>int32_t</type> <name>messageIdNumber</name></member>
- <member len="null-terminated">const <type>char</type>* <name>pMessage</name></member>
- <member optional="true"><type>uint32_t</type> <name>queueLabelCount</name></member>
- <member noautovalidity="true" optional="true" len="queueLabelCount"><type>VkDebugUtilsLabelEXT</type>* <name>pQueueLabels</name></member>
- <member optional="true"><type>uint32_t</type> <name>cmdBufLabelCount</name></member>
- <member noautovalidity="true" optional="true" len="cmdBufLabelCount"><type>VkDebugUtilsLabelEXT</type>* <name>pCmdBufLabels</name></member>
- <member><type>uint32_t</type> <name>objectCount</name></member>
- <member noautovalidity="true" len="objectCount"><type>VkDebugUtilsObjectNameInfoEXT</type>* <name>pObjects</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDeviceMemoryReportFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>deviceMemoryReport</name></member>
- </type>
- <type category="struct" name="VkDeviceDeviceMemoryReportCreateInfoEXT" allowduplicate="true" structextends="VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceMemoryReportFlagsEXT</type> <name>flags</name></member>
- <member><type>PFN_vkDeviceMemoryReportCallbackEXT</type> <name>pfnUserCallback</name></member>
- <member><type>void</type>* <name>pUserData</name></member>
- </type>
- <type category="struct" name="VkDeviceMemoryReportCallbackDataEXT" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceMemoryReportFlagsEXT</type> <name>flags</name></member>
- <member><type>VkDeviceMemoryReportEventTypeEXT</type> <name>type</name></member>
- <member><type>uint64_t</type> <name>memoryObjectId</name></member>
- <member><type>VkDeviceSize</type> <name>size</name></member>
- <member><type>VkObjectType</type> <name>objectType</name></member>
- <member><type>uint64_t</type> <name>objectHandle</name></member>
- <member><type>uint32_t</type> <name>heapIndex</name></member>
- </type>
- <type category="struct" name="VkImportMemoryHostPointerInfoEXT" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- <member optional="false"><type>void</type>* <name>pHostPointer</name></member>
- </type>
- <type category="struct" name="VkMemoryHostPointerPropertiesEXT" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member devicememorytypebits="1"><type>uint32_t</type> <name>memoryTypeBits</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalMemoryHostPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>minImportedHostPointerAlignment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceConservativeRasterizationPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>float</type> <name>primitiveOverestimationSize</name><comment>The size in pixels the primitive is enlarged at each edge during conservative rasterization</comment></member>
- <member limittype="max"><type>float</type> <name>maxExtraPrimitiveOverestimationSize</name><comment>The maximum additional overestimation the client can specify in the pipeline state</comment></member>
- <member limittype="noauto"><type>float</type> <name>extraPrimitiveOverestimationSizeGranularity</name><comment>The granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>primitiveUnderestimation</name><comment>true if the implementation supports conservative rasterization underestimation mode</comment></member>
- <member limittype="noauto"><type>VkBool32</type> <name>conservativePointAndLineRasterization</name><comment>true if conservative rasterization also applies to points and lines</comment></member>
- <member limittype="noauto"><type>VkBool32</type> <name>degenerateTrianglesRasterized</name><comment>true if degenerate triangles (those with zero area after snap) are rasterized</comment></member>
- <member limittype="noauto"><type>VkBool32</type> <name>degenerateLinesRasterized</name><comment>true if degenerate lines (those with zero length after snap) are rasterized</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fullyCoveredFragmentShaderInputVariable</name><comment>true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>conservativeRasterizationPostDepthCoverage</name><comment>true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask</comment></member>
- </type>
- <type category="struct" name="VkCalibratedTimestampInfoEXT">
- <member values="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkTimeDomainEXT</type> <name>timeDomain</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderCorePropertiesAMD" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderEngineCount</name><comment>number of shader engines</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderArraysPerEngineCount</name><comment>number of shader arrays</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>computeUnitsPerShaderArray</name><comment>number of physical CUs per shader array</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>simdPerComputeUnit</name><comment>number of SIMDs per compute unit</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>wavefrontsPerSimd</name><comment>number of wavefront slots in each SIMD</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>wavefrontSize</name><comment>maximum number of threads per wavefront</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>sgprsPerSimd</name><comment>number of physical SGPRs per SIMD</comment></member>
- <member limittype="min"><type>uint32_t</type> <name>minSgprAllocation</name><comment>minimum number of SGPRs that can be allocated by a wave</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxSgprAllocation</name><comment>number of available SGPRs</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>sgprAllocationGranularity</name><comment>SGPRs are allocated in groups of this size</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>vgprsPerSimd</name><comment>number of physical VGPRs per SIMD</comment></member>
- <member limittype="min"><type>uint32_t</type> <name>minVgprAllocation</name><comment>minimum number of VGPRs that can be allocated by a wave</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxVgprAllocation</name><comment>number of available VGPRs</comment></member>
- <member limittype="noauto"><type>uint32_t</type> <name>vgprAllocationGranularity</name><comment>VGPRs are allocated in groups of this size</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderCoreProperties2AMD" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name><comment>Pointer to next structure</comment></member>
- <member limittype="bitmask"><type>VkShaderCorePropertiesFlagsAMD</type> <name>shaderCoreFeatures</name><comment>features supported by the shader core</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>activeComputeUnitCount</name><comment>number of active compute units across all shader engines/arrays</comment></member>
- </type>
- <type category="struct" name="VkPipelineRasterizationConservativeStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineRasterizationConservativeStateCreateFlagsEXT</type> <name>flags</name><comment>Reserved</comment></member>
- <member><type>VkConservativeRasterizationModeEXT</type> <name>conservativeRasterizationMode</name><comment>Conservative rasterization mode</comment></member>
- <member><type>float</type> <name>extraPrimitiveOverestimationSize</name><comment>Extra overestimation to add to the primitive</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDescriptorIndexingFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderInputAttachmentArrayDynamicIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderUniformTexelBufferArrayDynamicIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageTexelBufferArrayDynamicIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderUniformTexelBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageTexelBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingUniformBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingSampledImageUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingStorageImageUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingStorageBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingUniformTexelBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingStorageTexelBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingUpdateUnusedWhilePending</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingPartiallyBound</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingVariableDescriptorCount</name></member>
- <member><type>VkBool32</type> <name>runtimeDescriptorArray</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDescriptorIndexingFeaturesEXT" alias="VkPhysicalDeviceDescriptorIndexingFeatures"/>
- <type category="struct" name="VkPhysicalDeviceDescriptorIndexingProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxUpdateAfterBindDescriptorsInAllPools</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>robustBufferAccessUpdateAfterBind</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>quadDivergentImplicitLod</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindSamplers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindUniformBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindStorageBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindSampledImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindStorageImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindInputAttachments</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageUpdateAfterBindResources</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindSamplers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindUniformBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindUniformBuffersDynamic</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindStorageBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindStorageBuffersDynamic</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindSampledImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindStorageImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindInputAttachments</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDescriptorIndexingPropertiesEXT" alias="VkPhysicalDeviceDescriptorIndexingProperties"/>
- <type category="struct" name="VkDescriptorSetLayoutBindingFlagsCreateInfo" structextends="VkDescriptorSetLayoutCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>bindingCount</name></member>
- <member len="bindingCount" optional="false,true">const <type>VkDescriptorBindingFlags</type>* <name>pBindingFlags</name></member>
- </type>
- <type category="struct" name="VkDescriptorSetLayoutBindingFlagsCreateInfoEXT" alias="VkDescriptorSetLayoutBindingFlagsCreateInfo"/>
- <type category="struct" name="VkDescriptorSetVariableDescriptorCountAllocateInfo" structextends="VkDescriptorSetAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>descriptorSetCount</name></member>
- <member len="descriptorSetCount">const <type>uint32_t</type>* <name>pDescriptorCounts</name></member>
- </type>
- <type category="struct" name="VkDescriptorSetVariableDescriptorCountAllocateInfoEXT" alias="VkDescriptorSetVariableDescriptorCountAllocateInfo"/>
- <type category="struct" name="VkDescriptorSetVariableDescriptorCountLayoutSupport" structextends="VkDescriptorSetLayoutSupport" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxVariableDescriptorCount</name></member>
- </type>
- <type category="struct" name="VkDescriptorSetVariableDescriptorCountLayoutSupportEXT" alias="VkDescriptorSetVariableDescriptorCountLayoutSupport"/>
- <type category="struct" name="VkAttachmentDescription2">
- <member values="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkAttachmentDescriptionFlags</type> <name>flags</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkSampleCountFlagBits</type> <name>samples</name></member>
- <member><type>VkAttachmentLoadOp</type> <name>loadOp</name><comment>Load operation for color or depth data</comment></member>
- <member><type>VkAttachmentStoreOp</type> <name>storeOp</name><comment>Store operation for color or depth data</comment></member>
- <member><type>VkAttachmentLoadOp</type> <name>stencilLoadOp</name><comment>Load operation for stencil data</comment></member>
- <member><type>VkAttachmentStoreOp</type> <name>stencilStoreOp</name><comment>Store operation for stencil data</comment></member>
- <member><type>VkImageLayout</type> <name>initialLayout</name></member>
- <member><type>VkImageLayout</type> <name>finalLayout</name></member>
- </type>
- <type category="struct" name="VkAttachmentDescription2KHR" alias="VkAttachmentDescription2"/>
- <type category="struct" name="VkAttachmentReference2">
- <member values="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>attachment</name></member>
- <member><type>VkImageLayout</type> <name>layout</name></member>
- <member noautovalidity="true"><type>VkImageAspectFlags</type> <name>aspectMask</name></member>
- </type>
- <type category="struct" name="VkAttachmentReference2KHR" alias="VkAttachmentReference2"/>
- <type category="struct" name="VkSubpassDescription2">
- <member values="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSubpassDescriptionFlags</type> <name>flags</name></member>
- <member><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></member>
- <member><type>uint32_t</type> <name>viewMask</name></member>
- <member optional="true"><type>uint32_t</type> <name>inputAttachmentCount</name></member>
- <member len="inputAttachmentCount">const <type>VkAttachmentReference2</type>* <name>pInputAttachments</name></member>
- <member optional="true"><type>uint32_t</type> <name>colorAttachmentCount</name></member>
- <member len="colorAttachmentCount">const <type>VkAttachmentReference2</type>* <name>pColorAttachments</name></member>
- <member optional="true" len="colorAttachmentCount">const <type>VkAttachmentReference2</type>* <name>pResolveAttachments</name></member>
- <member optional="true">const <type>VkAttachmentReference2</type>* <name>pDepthStencilAttachment</name></member>
- <member optional="true"><type>uint32_t</type> <name>preserveAttachmentCount</name></member>
- <member len="preserveAttachmentCount">const <type>uint32_t</type>* <name>pPreserveAttachments</name></member>
- </type>
- <type category="struct" name="VkSubpassDescription2KHR" alias="VkSubpassDescription2"/>
- <type category="struct" name="VkSubpassDependency2">
- <member values="VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>srcSubpass</name></member>
- <member><type>uint32_t</type> <name>dstSubpass</name></member>
- <member optional="true"><type>VkPipelineStageFlags</type> <name>srcStageMask</name></member>
- <member optional="true"><type>VkPipelineStageFlags</type> <name>dstStageMask</name></member>
- <member optional="true"><type>VkAccessFlags</type> <name>srcAccessMask</name></member>
- <member optional="true"><type>VkAccessFlags</type> <name>dstAccessMask</name></member>
- <member optional="true"><type>VkDependencyFlags</type> <name>dependencyFlags</name></member>
- <member><type>int32_t</type> <name>viewOffset</name></member>
- </type>
- <type category="struct" name="VkSubpassDependency2KHR" alias="VkSubpassDependency2"/>
- <type category="struct" name="VkRenderPassCreateInfo2">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkRenderPassCreateFlags</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentCount</name></member>
- <member len="attachmentCount">const <type>VkAttachmentDescription2</type>* <name>pAttachments</name></member>
- <member><type>uint32_t</type> <name>subpassCount</name></member>
- <member len="subpassCount">const <type>VkSubpassDescription2</type>* <name>pSubpasses</name></member>
- <member optional="true"><type>uint32_t</type> <name>dependencyCount</name></member>
- <member len="dependencyCount">const <type>VkSubpassDependency2</type>* <name>pDependencies</name></member>
- <member optional="true"><type>uint32_t</type> <name>correlatedViewMaskCount</name></member>
- <member len="correlatedViewMaskCount">const <type>uint32_t</type>* <name>pCorrelatedViewMasks</name></member>
- </type>
- <type category="struct" name="VkRenderPassCreateInfo2KHR" alias="VkRenderPassCreateInfo2"/>
- <type category="struct" name="VkSubpassBeginInfo">
- <member values="VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSubpassContents</type> <name>contents</name></member>
- </type>
- <type category="struct" name="VkSubpassBeginInfoKHR" alias="VkSubpassBeginInfo"/>
- <type category="struct" name="VkSubpassEndInfo">
- <member values="VK_STRUCTURE_TYPE_SUBPASS_END_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- </type>
- <type category="struct" name="VkSubpassEndInfoKHR" alias="VkSubpassEndInfo"/>
- <type category="struct" name="VkPhysicalDeviceTimelineSemaphoreFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>timelineSemaphore</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceTimelineSemaphoreFeaturesKHR" alias="VkPhysicalDeviceTimelineSemaphoreFeatures"/>
- <type category="struct" name="VkPhysicalDeviceTimelineSemaphoreProperties" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxTimelineSemaphoreValueDifference</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceTimelineSemaphorePropertiesKHR" alias="VkPhysicalDeviceTimelineSemaphoreProperties"/>
- <type category="struct" name="VkSemaphoreTypeCreateInfo" structextends="VkSemaphoreCreateInfo,VkPhysicalDeviceExternalSemaphoreInfo">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSemaphoreType</type> <name>semaphoreType</name></member>
- <member><type>uint64_t</type> <name>initialValue</name></member>
- </type>
- <type category="struct" name="VkSemaphoreTypeCreateInfoKHR" alias="VkSemaphoreTypeCreateInfo"/>
- <type category="struct" name="VkTimelineSemaphoreSubmitInfo" structextends="VkSubmitInfo,VkBindSparseInfo">
- <member values="VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>waitSemaphoreValueCount</name></member>
- <member optional="true" len="waitSemaphoreValueCount">const <type>uint64_t</type>* <name>pWaitSemaphoreValues</name></member>
- <member optional="true"><type>uint32_t</type> <name>signalSemaphoreValueCount</name></member>
- <member optional="true" len="signalSemaphoreValueCount">const <type>uint64_t</type>* <name>pSignalSemaphoreValues</name></member>
- </type>
- <type category="struct" name="VkTimelineSemaphoreSubmitInfoKHR" alias="VkTimelineSemaphoreSubmitInfo"/>
- <type category="struct" name="VkSemaphoreWaitInfo">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSemaphoreWaitFlags</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>semaphoreCount</name></member>
- <member len="semaphoreCount">const <type>VkSemaphore</type>* <name>pSemaphores</name></member>
- <member len="semaphoreCount">const <type>uint64_t</type>* <name>pValues</name></member>
- </type>
- <type category="struct" name="VkSemaphoreWaitInfoKHR" alias="VkSemaphoreWaitInfo"/>
- <type category="struct" name="VkSemaphoreSignalInfo">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSemaphore</type> <name>semaphore</name></member>
- <member><type>uint64_t</type> <name>value</name></member>
- </type>
- <type category="struct" name="VkSemaphoreSignalInfoKHR" alias="VkSemaphoreSignalInfo"/>
- <type category="struct" name="VkVertexInputBindingDivisorDescriptionEXT">
- <member><type>uint32_t</type> <name>binding</name></member>
- <member><type>uint32_t</type> <name>divisor</name></member>
- </type>
- <type category="struct" name="VkPipelineVertexInputDivisorStateCreateInfoEXT" structextends="VkPipelineVertexInputStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>vertexBindingDivisorCount</name></member>
- <member len="vertexBindingDivisorCount">const <type>VkVertexInputBindingDivisorDescriptionEXT</type>* <name>pVertexBindingDivisors</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxVertexAttribDivisor</name><comment>max value of vertex attribute divisor</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePCIBusInfoPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>pciDomain</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>pciBus</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>pciDevice</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>pciFunction</name></member>
- </type>
- <type category="struct" name="VkImportAndroidHardwareBufferInfoANDROID" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member>struct <type>AHardwareBuffer</type>* <name>buffer</name></member>
- </type>
- <type category="struct" name="VkAndroidHardwareBufferUsageANDROID" structextends="VkImageFormatProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>androidHardwareBufferUsage</name></member>
- </type>
- <type category="struct" name="VkAndroidHardwareBufferPropertiesANDROID" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceSize</type> <name>allocationSize</name></member>
- <member devicememorytypebits="1"><type>uint32_t</type> <name>memoryTypeBits</name></member>
- </type>
- <type category="struct" name="VkMemoryGetAndroidHardwareBufferInfoANDROID">
- <member values="VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- </type>
- <type category="struct" name="VkAndroidHardwareBufferFormatPropertiesANDROID" structextends="VkAndroidHardwareBufferPropertiesANDROID" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>uint64_t</type> <name>externalFormat</name></member>
- <member><type>VkFormatFeatureFlags</type> <name>formatFeatures</name></member>
- <member><type>VkComponentMapping</type> <name>samplerYcbcrConversionComponents</name></member>
- <member><type>VkSamplerYcbcrModelConversion</type> <name>suggestedYcbcrModel</name></member>
- <member><type>VkSamplerYcbcrRange</type> <name>suggestedYcbcrRange</name></member>
- <member><type>VkChromaLocation</type> <name>suggestedXChromaOffset</name></member>
- <member><type>VkChromaLocation</type> <name>suggestedYChromaOffset</name></member>
- </type>
- <type category="struct" name="VkCommandBufferInheritanceConditionalRenderingInfoEXT" structextends="VkCommandBufferInheritanceInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>conditionalRenderingEnable</name><comment>Whether this secondary command buffer may be executed during an active conditional rendering</comment></member>
- </type>
- <type category="struct" name="VkExternalFormatANDROID" structextends="VkImageCreateInfo,VkSamplerYcbcrConversionCreateInfo">
- <member values="VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>externalFormat</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevice8BitStorageFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>storageBuffer8BitAccess</name><comment>8-bit integer variables supported in StorageBuffer</comment></member>
- <member><type>VkBool32</type> <name>uniformAndStorageBuffer8BitAccess</name><comment>8-bit integer variables supported in StorageBuffer and Uniform</comment></member>
- <member><type>VkBool32</type> <name>storagePushConstant8</name><comment>8-bit integer variables supported in PushConstant</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDevice8BitStorageFeaturesKHR" alias="VkPhysicalDevice8BitStorageFeatures"/>
- <type category="struct" name="VkPhysicalDeviceConditionalRenderingFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>conditionalRendering</name></member>
- <member><type>VkBool32</type> <name>inheritedConditionalRendering</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVulkanMemoryModelFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>vulkanMemoryModel</name></member>
- <member><type>VkBool32</type> <name>vulkanMemoryModelDeviceScope</name></member>
- <member><type>VkBool32</type> <name>vulkanMemoryModelAvailabilityVisibilityChains</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVulkanMemoryModelFeaturesKHR" alias="VkPhysicalDeviceVulkanMemoryModelFeatures"/>
- <type category="struct" name="VkPhysicalDeviceShaderAtomicInt64Features" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderBufferInt64Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderSharedInt64Atomics</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderAtomicInt64FeaturesKHR" alias="VkPhysicalDeviceShaderAtomicInt64Features"/>
- <type category="struct" name="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat32Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat32AtomicAdd</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat64Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat64AtomicAdd</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat32Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat32AtomicAdd</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat64Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat64AtomicAdd</name></member>
- <member><type>VkBool32</type> <name>shaderImageFloat32Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderImageFloat32AtomicAdd</name></member>
- <member><type>VkBool32</type> <name>sparseImageFloat32Atomics</name></member>
- <member><type>VkBool32</type> <name>sparseImageFloat32AtomicAdd</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat16Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat16AtomicAdd</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat16AtomicMinMax</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat32AtomicMinMax</name></member>
- <member><type>VkBool32</type> <name>shaderBufferFloat64AtomicMinMax</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat16Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat16AtomicAdd</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat16AtomicMinMax</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat32AtomicMinMax</name></member>
- <member><type>VkBool32</type> <name>shaderSharedFloat64AtomicMinMax</name></member>
- <member><type>VkBool32</type> <name>shaderImageFloat32AtomicMinMax</name></member>
- <member><type>VkBool32</type> <name>sparseImageFloat32AtomicMinMax</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>vertexAttributeInstanceRateDivisor</name></member>
- <member><type>VkBool32</type> <name>vertexAttributeInstanceRateZeroDivisor</name></member>
- </type>
- <type category="struct" name="VkQueueFamilyCheckpointPropertiesNV" structextends="VkQueueFamilyProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkPipelineStageFlags</type> <name>checkpointExecutionStageMask</name></member>
- </type>
- <type category="struct" name="VkCheckpointDataNV" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkPipelineStageFlagBits</type> <name>stage</name></member>
- <member noautovalidity="true"><type>void</type>* <name>pCheckpointMarker</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDepthStencilResolveProperties" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedDepthResolveModes</name><comment>supported depth resolve modes</comment></member>
- <member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedStencilResolveModes</name><comment>supported stencil resolve modes</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>independentResolveNone</name><comment>depth and stencil resolve modes can be set independently if one of them is none</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>independentResolve</name><comment>depth and stencil resolve modes can be set independently</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDepthStencilResolvePropertiesKHR" alias="VkPhysicalDeviceDepthStencilResolveProperties"/>
- <type category="struct" name="VkSubpassDescriptionDepthStencilResolve" structextends="VkSubpassDescription2">
- <member values="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkResolveModeFlagBits</type> <name>depthResolveMode</name><comment>depth resolve mode</comment></member>
- <member noautovalidity="true"><type>VkResolveModeFlagBits</type> <name>stencilResolveMode</name><comment>stencil resolve mode</comment></member>
- <member optional="true">const <type>VkAttachmentReference2</type>* <name>pDepthStencilResolveAttachment</name><comment>depth/stencil resolve attachment</comment></member>
- </type>
- <type category="struct" name="VkSubpassDescriptionDepthStencilResolveKHR" alias="VkSubpassDescriptionDepthStencilResolve"/>
- <type category="struct" name="VkImageViewASTCDecodeModeEXT" structextends="VkImageViewCreateInfo">
- <member values="VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>decodeMode</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceASTCDecodeFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>decodeModeSharedExponent</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceTransformFeedbackFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>transformFeedback</name></member>
- <member><type>VkBool32</type> <name>geometryStreams</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceTransformFeedbackPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTransformFeedbackStreams</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTransformFeedbackBuffers</name></member>
- <member limittype="max"><type>VkDeviceSize</type> <name>maxTransformFeedbackBufferSize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTransformFeedbackStreamDataSize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTransformFeedbackBufferDataSize</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>maxTransformFeedbackBufferDataStride</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>transformFeedbackQueries</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>transformFeedbackStreamsLinesTriangles</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>transformFeedbackRasterizationStreamSelect</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>transformFeedbackDraw</name></member>
- </type>
- <type category="struct" name="VkPipelineRasterizationStateStreamCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineRasterizationStateStreamCreateFlagsEXT</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>rasterizationStream</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>representativeFragmentTest</name></member>
- </type>
- <type category="struct" name="VkPipelineRepresentativeFragmentTestStateCreateInfoNV" structextends="VkGraphicsPipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>representativeFragmentTestEnable</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExclusiveScissorFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>exclusiveScissor</name></member>
- </type>
- <type category="struct" name="VkPipelineViewportExclusiveScissorStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>exclusiveScissorCount</name></member>
- <member noautovalidity="true" len="exclusiveScissorCount">const <type>VkRect2D</type>* <name>pExclusiveScissors</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceCornerSampledImageFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>cornerSampledImage</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceComputeShaderDerivativesFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>computeDerivativeGroupQuads</name></member>
- <member><type>VkBool32</type> <name>computeDerivativeGroupLinear</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>fragmentShaderBarycentric</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderImageFootprintFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>imageFootprint</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>dedicatedAllocationImageAliasing</name></member>
- </type>
- <type category="struct" name="VkShadingRatePaletteNV">
- <member><type>uint32_t</type> <name>shadingRatePaletteEntryCount</name></member>
- <member len="shadingRatePaletteEntryCount">const <type>VkShadingRatePaletteEntryNV</type>* <name>pShadingRatePaletteEntries</name></member>
- </type>
- <type category="struct" name="VkPipelineViewportShadingRateImageStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shadingRateImageEnable</name></member>
- <member optional="true"><type>uint32_t</type> <name>viewportCount</name></member>
- <member noautovalidity="true" len="viewportCount">const <type>VkShadingRatePaletteNV</type>* <name>pShadingRatePalettes</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShadingRateImageFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shadingRateImage</name></member>
- <member><type>VkBool32</type> <name>shadingRateCoarseSampleOrder</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShadingRateImagePropertiesNV" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkExtent2D</type> <name>shadingRateTexelSize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>shadingRatePaletteSize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>shadingRateMaxCoarseSamples</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceInvocationMaskFeaturesHUAWEI" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>invocationMask</name></member>
- </type>
- <type category="struct" name="VkCoarseSampleLocationNV">
- <member><type>uint32_t</type> <name>pixelX</name></member>
- <member><type>uint32_t</type> <name>pixelY</name></member>
- <member><type>uint32_t</type> <name>sample</name></member>
- </type>
- <type category="struct" name="VkCoarseSampleOrderCustomNV">
- <member><type>VkShadingRatePaletteEntryNV</type> <name>shadingRate</name></member>
- <member><type>uint32_t</type> <name>sampleCount</name></member>
- <member><type>uint32_t</type> <name>sampleLocationCount</name></member>
- <member len="sampleLocationCount">const <type>VkCoarseSampleLocationNV</type>* <name>pSampleLocations</name></member>
- </type>
- <type category="struct" name="VkPipelineViewportCoarseSampleOrderStateCreateInfoNV" structextends="VkPipelineViewportStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkCoarseSampleOrderTypeNV</type> <name>sampleOrderType</name></member>
- <member optional="true"><type>uint32_t</type> <name>customSampleOrderCount</name></member>
- <member len="customSampleOrderCount">const <type>VkCoarseSampleOrderCustomNV</type>* <name>pCustomSampleOrders</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMeshShaderFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>taskShader</name></member>
- <member><type>VkBool32</type> <name>meshShader</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMeshShaderPropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDrawMeshTasksCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTaskWorkGroupInvocations</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTaskWorkGroupSize</name>[3]</member>
- <member limittype="max"><type>uint32_t</type> <name>maxTaskTotalMemorySize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxTaskOutputCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMeshWorkGroupInvocations</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMeshWorkGroupSize</name>[3]</member>
- <member limittype="max"><type>uint32_t</type> <name>maxMeshTotalMemorySize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMeshOutputVertices</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMeshOutputPrimitives</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMeshMultiviewViewCount</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>meshOutputPerVertexGranularity</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>meshOutputPerPrimitiveGranularity</name></member>
- </type>
- <type category="struct" name="VkDrawMeshTasksIndirectCommandNV">
- <member><type>uint32_t</type> <name>taskCount</name></member>
- <member><type>uint32_t</type> <name>firstTask</name></member>
- </type>
- <type category="struct" name="VkRayTracingShaderGroupCreateInfoNV">
- <member values="VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkRayTracingShaderGroupTypeKHR</type> <name>type</name></member>
- <member><type>uint32_t</type> <name>generalShader</name></member>
- <member><type>uint32_t</type> <name>closestHitShader</name></member>
- <member><type>uint32_t</type> <name>anyHitShader</name></member>
- <member><type>uint32_t</type> <name>intersectionShader</name></member>
- </type>
- <type category="struct" name="VkRayTracingShaderGroupCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkRayTracingShaderGroupTypeKHR</type> <name>type</name></member>
- <member><type>uint32_t</type> <name>generalShader</name></member>
- <member><type>uint32_t</type> <name>closestHitShader</name></member>
- <member><type>uint32_t</type> <name>anyHitShader</name></member>
- <member><type>uint32_t</type> <name>intersectionShader</name></member>
- <member optional="true">const <type>void</type>* <name>pShaderGroupCaptureReplayHandle</name></member>
- </type>
- <type category="struct" name="VkRayTracingPipelineCreateInfoNV">
- <member values="VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCreateFlags</type> <name>flags</name><comment>Pipeline creation flags</comment></member>
- <member><type>uint32_t</type> <name>stageCount</name></member>
- <member len="stageCount">const <type>VkPipelineShaderStageCreateInfo</type>* <name>pStages</name><comment>One entry for each active shader stage</comment></member>
- <member><type>uint32_t</type> <name>groupCount</name></member>
- <member len="groupCount">const <type>VkRayTracingShaderGroupCreateInfoNV</type>* <name>pGroups</name></member>
- <member><type>uint32_t</type> <name>maxRecursionDepth</name></member>
- <member><type>VkPipelineLayout</type> <name>layout</name><comment>Interface layout of the pipeline</comment></member>
- <member noautovalidity="true" optional="true"><type>VkPipeline</type> <name>basePipelineHandle</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of</comment></member>
- <member><type>int32_t</type> <name>basePipelineIndex</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of</comment></member>
- </type>
- <type category="struct" name="VkRayTracingPipelineCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCreateFlags</type> <name>flags</name><comment>Pipeline creation flags</comment></member>
- <member optional="true"><type>uint32_t</type> <name>stageCount</name></member>
- <member len="stageCount">const <type>VkPipelineShaderStageCreateInfo</type>* <name>pStages</name><comment>One entry for each active shader stage</comment></member>
- <member optional="true"><type>uint32_t</type> <name>groupCount</name></member>
- <member len="groupCount">const <type>VkRayTracingShaderGroupCreateInfoKHR</type>* <name>pGroups</name></member>
- <member><type>uint32_t</type> <name>maxPipelineRayRecursionDepth</name></member>
- <member optional="true">const <type>VkPipelineLibraryCreateInfoKHR</type>* <name>pLibraryInfo</name></member>
- <member optional="true">const <type>VkRayTracingPipelineInterfaceCreateInfoKHR</type>* <name>pLibraryInterface</name></member>
- <member optional="true">const <type>VkPipelineDynamicStateCreateInfo</type>* <name>pDynamicState</name></member>
- <member><type>VkPipelineLayout</type> <name>layout</name><comment>Interface layout of the pipeline</comment></member>
- <member noautovalidity="true" optional="true"><type>VkPipeline</type> <name>basePipelineHandle</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of</comment></member>
- <member><type>int32_t</type> <name>basePipelineIndex</name><comment>If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of</comment></member>
- </type>
- <type category="struct" name="VkGeometryTrianglesNV">
- <member values="VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkBuffer</type> <name>vertexData</name></member>
- <member><type>VkDeviceSize</type> <name>vertexOffset</name></member>
- <member><type>uint32_t</type> <name>vertexCount</name></member>
- <member><type>VkDeviceSize</type> <name>vertexStride</name></member>
- <member><type>VkFormat</type> <name>vertexFormat</name></member>
- <member optional="true"><type>VkBuffer</type> <name>indexData</name></member>
- <member><type>VkDeviceSize</type> <name>indexOffset</name></member>
- <member><type>uint32_t</type> <name>indexCount</name></member>
- <member><type>VkIndexType</type> <name>indexType</name></member>
- <member optional="true"><type>VkBuffer</type> <name>transformData</name><comment>Optional reference to array of floats representing a 3x4 row major affine transformation matrix.</comment></member>
- <member><type>VkDeviceSize</type> <name>transformOffset</name></member>
- </type>
- <type category="struct" name="VkGeometryAABBNV">
- <member values="VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkBuffer</type> <name>aabbData</name></member>
- <member><type>uint32_t</type> <name>numAABBs</name></member>
- <member><type>uint32_t</type> <name>stride</name><comment>Stride in bytes between AABBs</comment></member>
- <member><type>VkDeviceSize</type> <name>offset</name><comment>Offset in bytes of the first AABB in aabbData</comment></member>
- </type>
- <type category="struct" name="VkGeometryDataNV">
- <member><type>VkGeometryTrianglesNV</type> <name>triangles</name></member>
- <member><type>VkGeometryAABBNV</type> <name>aabbs</name></member>
- </type>
- <type category="struct" name="VkGeometryNV">
- <member values="VK_STRUCTURE_TYPE_GEOMETRY_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkGeometryTypeKHR</type> <name>geometryType</name></member>
- <member><type>VkGeometryDataNV</type> <name>geometry</name></member>
- <member optional="true"><type>VkGeometryFlagsKHR</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureInfoNV">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAccelerationStructureTypeNV</type> <name>type</name></member>
- <member optional="true"><type>VkBuildAccelerationStructureFlagsNV</type><name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>instanceCount</name></member>
- <member optional="true"><type>uint32_t</type> <name>geometryCount</name></member>
- <member len="geometryCount">const <type>VkGeometryNV</type>* <name>pGeometries</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureCreateInfoNV">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceSize</type> <name>compactedSize</name></member>
- <member><type>VkAccelerationStructureInfoNV</type> <name>info</name></member>
- </type>
- <type category="struct" name="VkBindAccelerationStructureMemoryInfoNV">
- <member values="VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAccelerationStructureNV</type> <name>accelerationStructure</name></member>
- <member devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- <member devicememoryoffset="1"><type>VkDeviceSize</type> <name>memoryOffset</name></member>
- <member optional="true"><type>uint32_t</type> <name>deviceIndexCount</name></member>
- <member len="deviceIndexCount">const <type>uint32_t</type>* <name>pDeviceIndices</name></member>
- </type>
- <type category="struct" name="VkWriteDescriptorSetAccelerationStructureKHR" structextends="VkWriteDescriptorSet">
- <member values="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>accelerationStructureCount</name></member>
- <member optional="false,true" len="accelerationStructureCount">const <type>VkAccelerationStructureKHR</type>* <name>pAccelerationStructures</name></member>
- </type>
- <type category="struct" name="VkWriteDescriptorSetAccelerationStructureNV" structextends="VkWriteDescriptorSet">
- <member values="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>accelerationStructureCount</name></member>
- <member optional="false,true" len="accelerationStructureCount">const <type>VkAccelerationStructureNV</type>* <name>pAccelerationStructures</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureMemoryRequirementsInfoNV">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAccelerationStructureMemoryRequirementsTypeNV</type> <name>type</name></member>
- <member><type>VkAccelerationStructureNV</type> <name>accelerationStructure</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceAccelerationStructureFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>accelerationStructure</name></member>
- <member><type>VkBool32</type> <name>accelerationStructureCaptureReplay</name></member>
- <member><type>VkBool32</type> <name>accelerationStructureIndirectBuild</name></member>
- <member><type>VkBool32</type> <name>accelerationStructureHostCommands</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingAccelerationStructureUpdateAfterBind</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRayTracingPipelineFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>rayTracingPipeline</name></member>
- <member><type>VkBool32</type> <name>rayTracingPipelineShaderGroupHandleCaptureReplay</name></member>
- <member><type>VkBool32</type> <name>rayTracingPipelineShaderGroupHandleCaptureReplayMixed</name></member>
- <member><type>VkBool32</type> <name>rayTracingPipelineTraceRaysIndirect</name></member>
- <member><type>VkBool32</type> <name>rayTraversalPrimitiveCulling</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRayQueryFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>rayQuery</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceAccelerationStructurePropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxGeometryCount</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxInstanceCount</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxPrimitiveCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorAccelerationStructures</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindAccelerationStructures</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetAccelerationStructures</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindAccelerationStructures</name></member>
- <member limittype="min"><type>uint32_t</type> <name>minAccelerationStructureScratchOffsetAlignment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRayTracingPipelinePropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderGroupHandleSize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxRayRecursionDepth</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxShaderGroupStride</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderGroupBaseAlignment</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderGroupHandleCaptureReplaySize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxRayDispatchInvocationCount</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderGroupHandleAlignment</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxRayHitAttributeSize</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRayTracingPropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderGroupHandleSize</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxRecursionDepth</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxShaderGroupStride</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>shaderGroupBaseAlignment</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxGeometryCount</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxInstanceCount</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxTriangleCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetAccelerationStructures</name></member>
- </type>
- <type category="struct" name="VkStridedDeviceAddressRegionKHR">
- <member optional="true"><type>VkDeviceAddress</type> <name>deviceAddress</name></member>
- <member><type>VkDeviceSize</type> <name>stride</name></member>
- <member><type>VkDeviceSize</type> <name>size</name></member>
- </type>
- <type category="struct" name="VkTraceRaysIndirectCommandKHR">
- <member><type>uint32_t</type> <name>width</name></member>
- <member><type>uint32_t</type> <name>height</name></member>
- <member><type>uint32_t</type> <name>depth</name></member>
- </type>
- <type category="struct" name="VkDrmFormatModifierPropertiesListEXT" returnedonly="true" structextends="VkFormatProperties2">
- <member values="VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>drmFormatModifierCount</name></member>
- <member optional="true,false" len="drmFormatModifierCount"><type>VkDrmFormatModifierPropertiesEXT</type>* <name>pDrmFormatModifierProperties</name></member>
- </type>
- <type category="struct" name="VkDrmFormatModifierPropertiesEXT" returnedonly="true">
- <member><type>uint64_t</type> <name>drmFormatModifier</name></member>
- <member><type>uint32_t</type> <name>drmFormatModifierPlaneCount</name></member>
- <member><type>VkFormatFeatureFlags</type> <name>drmFormatModifierTilingFeatures</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceImageDrmFormatModifierInfoEXT" structextends="VkPhysicalDeviceImageFormatInfo2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>drmFormatModifier</name></member>
- <member><type>VkSharingMode</type> <name>sharingMode</name></member>
- <member optional="true"><type>uint32_t</type> <name>queueFamilyIndexCount</name></member>
- <member noautovalidity="true" len="queueFamilyIndexCount">const <type>uint32_t</type>* <name>pQueueFamilyIndices</name></member>
- </type>
- <type category="struct" name="VkImageDrmFormatModifierListCreateInfoEXT" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>drmFormatModifierCount</name></member>
- <member len="drmFormatModifierCount">const <type>uint64_t</type>* <name>pDrmFormatModifiers</name></member>
- </type>
- <type category="struct" name="VkImageDrmFormatModifierExplicitCreateInfoEXT" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>drmFormatModifier</name></member>
- <member optional="false"><type>uint32_t</type> <name>drmFormatModifierPlaneCount</name></member>
- <member len="drmFormatModifierPlaneCount">const <type>VkSubresourceLayout</type>* <name>pPlaneLayouts</name></member>
- </type>
- <type category="struct" name="VkImageDrmFormatModifierPropertiesEXT" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>drmFormatModifier</name></member>
- </type>
- <type category="struct" name="VkImageStencilUsageCreateInfo" structextends="VkImageCreateInfo,VkPhysicalDeviceImageFormatInfo2">
- <member values="VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageUsageFlags</type> <name>stencilUsage</name></member>
- </type>
- <type category="struct" name="VkImageStencilUsageCreateInfoEXT" alias="VkImageStencilUsageCreateInfo"/>
- <type category="struct" name="VkDeviceMemoryOverallocationCreateInfoAMD" structextends="VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkMemoryOverallocationBehaviorAMD</type> <name>overallocationBehavior</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentDensityMapFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>fragmentDensityMap</name></member>
- <member><type>VkBool32</type> <name>fragmentDensityMapDynamic</name></member>
- <member><type>VkBool32</type> <name>fragmentDensityMapNonSubsampledImages</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentDensityMap2FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>fragmentDensityMapDeferred</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentDensityMapPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="min"><type>VkExtent2D</type> <name>minFragmentDensityTexelSize</name></member>
- <member limittype="max"><type>VkExtent2D</type> <name>maxFragmentDensityTexelSize</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentDensityInvocations</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentDensityMap2PropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkBool32</type> <name>subsampledLoads</name></member>
- <member limittype="noauto"><type>VkBool32</type> <name>subsampledCoarseReconstructionEarlyAccess</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxSubsampledArrayLayers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetSubsampledSamplers</name></member>
- </type>
- <type category="struct" name="VkRenderPassFragmentDensityMapCreateInfoEXT" structextends="VkRenderPassCreateInfo,VkRenderPassCreateInfo2">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAttachmentReference</type> <name>fragmentDensityMapAttachment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceScalarBlockLayoutFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>scalarBlockLayout</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceScalarBlockLayoutFeaturesEXT" alias="VkPhysicalDeviceScalarBlockLayoutFeatures"/>
- <type category="struct" name="VkSurfaceProtectedCapabilitiesKHR" structextends="VkSurfaceCapabilities2KHR">
- <member values="VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>supportsProtected</name><comment>Represents if surface can be protected</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceUniformBufferStandardLayoutFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>uniformBufferStandardLayout</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR" alias="VkPhysicalDeviceUniformBufferStandardLayoutFeatures"/>
- <type category="struct" name="VkPhysicalDeviceDepthClipEnableFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>depthClipEnable</name></member>
- </type>
- <type category="struct" name="VkPipelineRasterizationDepthClipStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineRasterizationDepthClipStateCreateFlagsEXT</type> <name>flags</name><comment>Reserved</comment></member>
- <member><type>VkBool32</type> <name>depthClipEnable</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMemoryBudgetPropertiesEXT" structextends="VkPhysicalDeviceMemoryProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceSize</type> <name>heapBudget</name>[<enum>VK_MAX_MEMORY_HEAPS</enum>]</member>
- <member><type>VkDeviceSize</type> <name>heapUsage</name>[<enum>VK_MAX_MEMORY_HEAPS</enum>]</member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMemoryPriorityFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>memoryPriority</name></member>
- </type>
- <type category="struct" name="VkMemoryPriorityAllocateInfoEXT" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>float</type> <name>priority</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>pageableDeviceLocalMemory</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceBufferDeviceAddressFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddress</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddressCaptureReplay</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddressMultiDevice</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceBufferDeviceAddressFeaturesKHR" alias="VkPhysicalDeviceBufferDeviceAddressFeatures"/>
- <type category="struct" name="VkPhysicalDeviceBufferDeviceAddressFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddress</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddressCaptureReplay</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddressMultiDevice</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceBufferAddressFeaturesEXT" alias="VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"/>
- <type category="struct" name="VkBufferDeviceAddressInfo">
- <member values="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBuffer</type> <name>buffer</name></member>
- </type>
- <type category="struct" name="VkBufferDeviceAddressInfoKHR" alias="VkBufferDeviceAddressInfo"/>
- <type category="struct" name="VkBufferDeviceAddressInfoEXT" alias="VkBufferDeviceAddressInfo"/>
- <type category="struct" name="VkBufferOpaqueCaptureAddressCreateInfo" structextends="VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>opaqueCaptureAddress</name></member>
- </type>
- <type category="struct" name="VkBufferOpaqueCaptureAddressCreateInfoKHR" alias="VkBufferOpaqueCaptureAddressCreateInfo"/>
- <type category="struct" name="VkBufferDeviceAddressCreateInfoEXT" structextends="VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceAddress</type> <name>deviceAddress</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceImageViewImageFormatInfoEXT" structextends="VkPhysicalDeviceImageFormatInfo2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkImageViewType</type> <name>imageViewType</name></member>
- </type>
- <type category="struct" name="VkFilterCubicImageViewImageFormatPropertiesEXT" returnedonly="true" structextends="VkImageFormatProperties2">
- <member values="VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>filterCubic</name><comment>The combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT</comment></member>
- <member><type>VkBool32</type> <name>filterCubicMinmax</name><comment>The combination of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT and ReductionMode of Min or Max</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceImagelessFramebufferFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>imagelessFramebuffer</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceImagelessFramebufferFeaturesKHR" alias="VkPhysicalDeviceImagelessFramebufferFeatures"/>
- <type category="struct" name="VkFramebufferAttachmentsCreateInfo" structextends="VkFramebufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentImageInfoCount</name></member>
- <member len="attachmentImageInfoCount">const <type>VkFramebufferAttachmentImageInfo</type>* <name>pAttachmentImageInfos</name></member>
- </type>
- <type category="struct" name="VkFramebufferAttachmentsCreateInfoKHR" alias="VkFramebufferAttachmentsCreateInfo"/>
- <type category="struct" name="VkFramebufferAttachmentImageInfo">
- <member values="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImageCreateFlags</type> <name>flags</name><comment>Image creation flags</comment></member>
- <member><type>VkImageUsageFlags</type> <name>usage</name><comment>Image usage flags</comment></member>
- <member><type>uint32_t</type> <name>width</name></member>
- <member><type>uint32_t</type> <name>height</name></member>
- <member><type>uint32_t</type> <name>layerCount</name></member>
- <member optional="true"><type>uint32_t</type> <name>viewFormatCount</name></member>
- <member len="viewFormatCount">const <type>VkFormat</type>* <name>pViewFormats</name></member>
- </type>
- <type category="struct" name="VkFramebufferAttachmentImageInfoKHR" alias="VkFramebufferAttachmentImageInfo"/>
- <type category="struct" name="VkRenderPassAttachmentBeginInfo" structextends="VkRenderPassBeginInfo">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentCount</name></member>
- <member len="attachmentCount">const <type>VkImageView</type>* <name>pAttachments</name></member>
- </type>
- <type category="struct" name="VkRenderPassAttachmentBeginInfoKHR" alias="VkRenderPassAttachmentBeginInfo"/>
- <type category="struct" name="VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>textureCompressionASTC_HDR</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceCooperativeMatrixFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>cooperativeMatrix</name></member>
- <member><type>VkBool32</type> <name>cooperativeMatrixRobustBufferAccess</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceCooperativeMatrixPropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkShaderStageFlags</type> <name>cooperativeMatrixSupportedStages</name></member>
- </type>
- <type category="struct" name="VkCooperativeMatrixPropertiesNV">
- <member values="VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>MSize</name></member>
- <member><type>uint32_t</type> <name>NSize</name></member>
- <member><type>uint32_t</type> <name>KSize</name></member>
- <member><type>VkComponentTypeNV</type> <name>AType</name></member>
- <member><type>VkComponentTypeNV</type> <name>BType</name></member>
- <member><type>VkComponentTypeNV</type> <name>CType</name></member>
- <member><type>VkComponentTypeNV</type> <name>DType</name></member>
- <member><type>VkScopeNV</type> <name>scope</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>ycbcrImageArrays</name></member>
- </type>
- <type category="struct" name="VkImageViewHandleInfoNVX">
- <member values="VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageView</type> <name>imageView</name></member>
- <member><type>VkDescriptorType</type> <name>descriptorType</name></member>
- <member optional="true"><type>VkSampler</type> <name>sampler</name></member>
- </type>
- <type category="struct" name="VkImageViewAddressPropertiesNVX" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceAddress</type> <name>deviceAddress</name></member>
- <member><type>VkDeviceSize</type> <name>size</name></member>
- </type>
- <type category="struct" name="VkPresentFrameTokenGGP" structextends="VkPresentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>GgpFrameToken</type> <name>frameToken</name></member>
- </type>
- <type category="struct" name="VkPipelineCreationFeedbackEXT" returnedonly="true">
- <member><type>VkPipelineCreationFeedbackFlagsEXT</type> <name>flags</name></member>
- <member><type>uint64_t</type> <name>duration</name></member>
- </type>
- <type category="struct" name="VkPipelineCreationFeedbackCreateInfoEXT" structextends="VkGraphicsPipelineCreateInfo,VkComputePipelineCreateInfo,VkRayTracingPipelineCreateInfoNV,VkRayTracingPipelineCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPipelineCreationFeedbackEXT</type>* <name>pPipelineCreationFeedback</name><comment>Output pipeline creation feedback.</comment></member>
- <member><type>uint32_t</type> <name>pipelineStageCreationFeedbackCount</name></member>
- <member len="pipelineStageCreationFeedbackCount"><type>VkPipelineCreationFeedbackEXT</type>* <name>pPipelineStageCreationFeedbacks</name><comment>One entry for each shader stage specified in the parent Vk*PipelineCreateInfo struct</comment></member>
- </type>
- <type category="struct" name="VkSurfaceFullScreenExclusiveInfoEXT" structextends="VkPhysicalDeviceSurfaceInfo2KHR,VkSwapchainCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkFullScreenExclusiveEXT</type> <name>fullScreenExclusive</name></member>
- </type>
- <type category="struct" name="VkSurfaceFullScreenExclusiveWin32InfoEXT" structextends="VkPhysicalDeviceSurfaceInfo2KHR,VkSwapchainCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>HMONITOR</type> <name>hmonitor</name></member>
- </type>
- <type category="struct" name="VkSurfaceCapabilitiesFullScreenExclusiveEXT" structextends="VkSurfaceCapabilities2KHR">
- <member values="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>fullScreenExclusiveSupported</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePerformanceQueryFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>performanceCounterQueryPools</name><comment>performance counters supported in query pools</comment></member>
- <member><type>VkBool32</type> <name>performanceCounterMultipleQueryPools</name><comment>performance counters from multiple query pools can be accessed in the same primary command buffer</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePerformanceQueryPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask" noautovalidity="true"><type>VkBool32</type> <name>allowCommandBufferQueryCopies</name><comment>Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults</comment></member>
- </type>
- <type category="struct" name="VkPerformanceCounterKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkPerformanceCounterUnitKHR</type> <name>unit</name></member>
- <member><type>VkPerformanceCounterScopeKHR</type> <name>scope</name></member>
- <member><type>VkPerformanceCounterStorageKHR</type> <name>storage</name></member>
- <member><type>uint8_t</type> <name>uuid</name>[<enum>VK_UUID_SIZE</enum>]</member>
- </type>
- <type category="struct" name="VkPerformanceCounterDescriptionKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPerformanceCounterDescriptionFlagsKHR</type> <name>flags</name></member>
- <member><type>char</type> <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>char</type> <name>category</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>char</type> <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- </type>
- <type category="struct" name="VkQueryPoolPerformanceCreateInfoKHR" structextends="VkQueryPoolCreateInfo">
- <member values="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>queueFamilyIndex</name></member>
- <member><type>uint32_t</type> <name>counterIndexCount</name></member>
- <member len="counterIndexCount">const <type>uint32_t</type>* <name>pCounterIndices</name></member>
- </type>
- <type category="union" name="VkPerformanceCounterResultKHR" comment="// Union of all the possible return types a counter result could return">
- <member><type>int32_t</type> <name>int32</name></member>
- <member><type>int64_t</type> <name>int64</name></member>
- <member><type>uint32_t</type> <name>uint32</name></member>
- <member><type>uint64_t</type> <name>uint64</name></member>
- <member><type>float</type> <name>float32</name></member>
- <member><type>double</type> <name>float64</name></member>
- </type>
- <type category="struct" name="VkAcquireProfilingLockInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkAcquireProfilingLockFlagsKHR</type> <name>flags</name><comment>Acquire profiling lock flags</comment></member>
- <member><type>uint64_t</type> <name>timeout</name></member>
- </type>
- <type category="struct" name="VkPerformanceQuerySubmitInfoKHR" structextends="VkSubmitInfo,VkSubmitInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>counterPassIndex</name><comment>Index for which counter pass to submit</comment></member>
- </type>
- <type category="struct" name="VkHeadlessSurfaceCreateInfoEXT">
- <member values="VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkHeadlessSurfaceCreateFlagsEXT</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceCoverageReductionModeFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>coverageReductionMode</name></member>
- </type>
- <type category="struct" name="VkPipelineCoverageReductionStateCreateInfoNV" structextends="VkPipelineMultisampleStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCoverageReductionStateCreateFlagsNV</type> <name>flags</name></member>
- <member><type>VkCoverageReductionModeNV</type> <name>coverageReductionMode</name></member>
- </type>
- <type category="struct" name="VkFramebufferMixedSamplesCombinationNV" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkCoverageReductionModeNV</type> <name>coverageReductionMode</name></member>
- <member><type>VkSampleCountFlagBits</type> <name>rasterizationSamples</name></member>
- <member><type>VkSampleCountFlags</type> <name>depthStencilSamples</name></member>
- <member><type>VkSampleCountFlags</type> <name>colorSamples</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderIntegerFunctions2</name></member>
- </type>
- <type category="union" name="VkPerformanceValueDataINTEL">
- <member selection="VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL"><type>uint32_t</type> <name>value32</name></member>
- <member selection="VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL"><type>uint64_t</type> <name>value64</name></member>
- <member selection="VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL"><type>float</type> <name>valueFloat</name></member>
- <member selection="VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL"><type>VkBool32</type> <name>valueBool</name></member>
- <member selection="VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL" len="null-terminated">const <type>char</type>* <name>valueString</name></member>
- </type>
- <type category="struct" name="VkPerformanceValueINTEL">
- <member><type>VkPerformanceValueTypeINTEL</type> <name>type</name></member>
- <member selector="type" noautovalidity="true"><type>VkPerformanceValueDataINTEL</type> <name>data</name></member>
- </type>
- <type category="struct" name="VkInitializePerformanceApiInfoINTEL" >
- <member values="VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>void</type>* <name>pUserData</name></member>
- </type>
- <type category="struct" name="VkQueryPoolPerformanceQueryCreateInfoINTEL" structextends="VkQueryPoolCreateInfo">
- <member values="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkQueryPoolSamplingModeINTEL</type> <name>performanceCountersSampling</name></member>
- </type>
- <type category="struct" name="VkQueryPoolCreateInfoINTEL" alias="VkQueryPoolPerformanceQueryCreateInfoINTEL"/>
- <type category="struct" name="VkPerformanceMarkerInfoINTEL">
- <member values="VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>marker</name></member>
- </type>
- <type category="struct" name="VkPerformanceStreamMarkerInfoINTEL">
- <member values="VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>marker</name></member>
- </type>
- <type category="struct" name="VkPerformanceOverrideInfoINTEL">
- <member values="VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPerformanceOverrideTypeINTEL</type> <name>type</name></member>
- <member><type>VkBool32</type> <name>enable</name></member>
- <member><type>uint64_t</type> <name>parameter</name></member>
- </type>
- <type category="struct" name="VkPerformanceConfigurationAcquireInfoINTEL">
- <member values="VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPerformanceConfigurationTypeINTEL</type> <name>type</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderClockFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderSubgroupClock</name></member>
- <member><type>VkBool32</type> <name>shaderDeviceClock</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceIndexTypeUint8FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>indexTypeUint8</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderSMBuiltinsPropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>shaderSMCount</name></member>
- <member limittype="max"><type>uint32_t</type> <name>shaderWarpsPerSM</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderSMBuiltinsFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderSMBuiltins</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name><comment>Pointer to next structure</comment></member>
- <member><type>VkBool32</type> <name>fragmentShaderSampleInterlock</name></member>
- <member><type>VkBool32</type> <name>fragmentShaderPixelInterlock</name></member>
- <member><type>VkBool32</type> <name>fragmentShaderShadingRateInterlock</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>separateDepthStencilLayouts</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR" alias="VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"/>
- <type category="struct" name="VkAttachmentReferenceStencilLayout" structextends="VkAttachmentReference2">
- <member values="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkImageLayout</type> <name>stencilLayout</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>primitiveTopologyListRestart</name></member>
- <member><type>VkBool32</type> <name>primitiveTopologyPatchListRestart</name></member>
- </type>
- <type category="struct" name="VkAttachmentReferenceStencilLayoutKHR" alias="VkAttachmentReferenceStencilLayout"/>
- <type category="struct" name="VkAttachmentDescriptionStencilLayout" structextends="VkAttachmentDescription2">
- <member values="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkImageLayout</type> <name>stencilInitialLayout</name></member>
- <member><type>VkImageLayout</type> <name>stencilFinalLayout</name></member>
- </type>
- <type category="struct" name="VkAttachmentDescriptionStencilLayoutKHR" alias="VkAttachmentDescriptionStencilLayout"/>
- <type category="struct" name="VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>pipelineExecutableInfo</name></member>
- </type>
- <type category="struct" name="VkPipelineInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPipeline</type> <name>pipeline</name></member>
- </type>
- <type category="struct" name="VkPipelineExecutablePropertiesKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkShaderStageFlags</type> <name>stages</name></member>
- <member><type>char</type> <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>char</type> <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>uint32_t</type> <name>subgroupSize</name></member>
- </type>
- <type category="struct" name="VkPipelineExecutableInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkPipeline</type> <name>pipeline</name></member>
- <member><type>uint32_t</type> <name>executableIndex</name></member>
- </type>
- <type category="union" name="VkPipelineExecutableStatisticValueKHR" returnedonly="true">
- <member selection="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR"><type>VkBool32</type> <name>b32</name></member>
- <member selection="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR"><type>int64_t</type> <name>i64</name></member>
- <member selection="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR"><type>uint64_t</type> <name>u64</name></member>
- <member selection="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR"><type>double</type> <name>f64</name></member>
- </type>
- <type category="struct" name="VkPipelineExecutableStatisticKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>char</type> <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>char</type> <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>VkPipelineExecutableStatisticFormatKHR</type> <name>format</name></member>
- <member selector="format" noautovalidity="true"><type>VkPipelineExecutableStatisticValueKHR</type> <name>value</name></member>
- </type>
- <type category="struct" name="VkPipelineExecutableInternalRepresentationKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>char</type> <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>char</type> <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>VkBool32</type> <name>isText</name></member>
- <member><type>size_t</type> <name>dataSize</name></member>
- <member optional="true" len="dataSize"><type>void</type>* <name>pData</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderDemoteToHelperInvocation</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>texelBufferAlignment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>storageTexelBufferOffsetAlignmentBytes</name></member>
- <member limittype="noauto"><type>VkBool32</type> <name>storageTexelBufferOffsetSingleTexelAlignment</name></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>uniformTexelBufferOffsetAlignmentBytes</name></member>
- <member limittype="noauto"><type>VkBool32</type> <name>uniformTexelBufferOffsetSingleTexelAlignment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSubgroupSizeControlFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>subgroupSizeControl</name></member>
- <member><type>VkBool32</type> <name>computeFullSubgroups</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSubgroupSizeControlPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="min" noautovalidity="true"><type>uint32_t</type> <name>minSubgroupSize</name><comment>The minimum subgroup size supported by this device</comment></member>
- <member limittype="max" noautovalidity="true"><type>uint32_t</type> <name>maxSubgroupSize</name><comment>The maximum subgroup size supported by this device</comment></member>
- <member limittype="max" noautovalidity="true"><type>uint32_t</type> <name>maxComputeWorkgroupSubgroups</name><comment>The maximum number of subgroups supported in a workgroup</comment></member>
- <member limittype="bitmask"><type>VkShaderStageFlags</type> <name>requiredSubgroupSizeStages</name><comment>The shader stages that support specifying a subgroup size</comment></member>
- </type>
- <type category="struct" name="VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT" returnedonly="true" structextends="VkPipelineShaderStageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>requiredSubgroupSize</name></member>
- </type>
- <type category="struct" name="VkSubpassShadingPipelineCreateInfoHUAWEI" returnedonly="true" structextends="VkComputePipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkRenderPass</type> <name>renderPass</name></member>
- <member><type>uint32_t</type> <name>subpass</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSubpassShadingPropertiesHUAWEI" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>maxSubpassShadingWorkgroupSizeAspectRatio</name></member>
- </type>
- <type category="struct" name="VkMemoryOpaqueCaptureAddressAllocateInfo" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>opaqueCaptureAddress</name></member>
- </type>
- <type category="struct" name="VkMemoryOpaqueCaptureAddressAllocateInfoKHR" alias="VkMemoryOpaqueCaptureAddressAllocateInfo"/>
- <type category="struct" name="VkDeviceMemoryOpaqueCaptureAddressInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></member>
- </type>
- <type category="struct" name="VkDeviceMemoryOpaqueCaptureAddressInfoKHR" alias="VkDeviceMemoryOpaqueCaptureAddressInfo"/>
- <type category="struct" name="VkPhysicalDeviceLineRasterizationFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>rectangularLines</name></member>
- <member><type>VkBool32</type> <name>bresenhamLines</name></member>
- <member><type>VkBool32</type> <name>smoothLines</name></member>
- <member><type>VkBool32</type> <name>stippledRectangularLines</name></member>
- <member><type>VkBool32</type> <name>stippledBresenhamLines</name></member>
- <member><type>VkBool32</type> <name>stippledSmoothLines</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceLineRasterizationPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>lineSubPixelPrecisionBits</name></member>
- </type>
- <type category="struct" name="VkPipelineRasterizationLineStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkLineRasterizationModeEXT</type> <name>lineRasterizationMode</name></member>
- <member><type>VkBool32</type> <name>stippledLineEnable</name></member>
- <member><type>uint32_t</type> <name>lineStippleFactor</name></member>
- <member><type>uint16_t</type> <name>lineStipplePattern</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>pipelineCreationCacheControl</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVulkan11Features" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>storageBuffer16BitAccess</name><comment>16-bit integer/floating-point variables supported in BufferBlock</comment></member>
- <member><type>VkBool32</type> <name>uniformAndStorageBuffer16BitAccess</name><comment>16-bit integer/floating-point variables supported in BufferBlock and Block</comment></member>
- <member><type>VkBool32</type> <name>storagePushConstant16</name><comment>16-bit integer/floating-point variables supported in PushConstant</comment></member>
- <member><type>VkBool32</type> <name>storageInputOutput16</name><comment>16-bit integer/floating-point variables supported in shader inputs and outputs</comment></member>
- <member><type>VkBool32</type> <name>multiview</name><comment>Multiple views in a renderpass</comment></member>
- <member><type>VkBool32</type> <name>multiviewGeometryShader</name><comment>Multiple views in a renderpass w/ geometry shader</comment></member>
- <member><type>VkBool32</type> <name>multiviewTessellationShader</name><comment>Multiple views in a renderpass w/ tessellation shader</comment></member>
- <member><type>VkBool32</type> <name>variablePointersStorageBuffer</name></member>
- <member><type>VkBool32</type> <name>variablePointers</name></member>
- <member><type>VkBool32</type> <name>protectedMemory</name></member>
- <member><type>VkBool32</type> <name>samplerYcbcrConversion</name><comment>Sampler color conversion supported</comment></member>
- <member><type>VkBool32</type> <name>shaderDrawParameters</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVulkan11Properties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint8_t</type> <name>deviceUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
- <member limittype="noauto"><type>uint8_t</type> <name>driverUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
- <member limittype="noauto"><type>uint8_t</type> <name>deviceLUID</name>[<enum>VK_LUID_SIZE</enum>]</member>
- <member limittype="noauto"><type>uint32_t</type> <name>deviceNodeMask</name></member>
- <member limittype="noauto"><type>VkBool32</type> <name>deviceLUIDValid</name></member>
- <member limittype="noauto" noautovalidity="true"><type>uint32_t</type> <name>subgroupSize</name><comment>The size of a subgroup for this queue.</comment></member>
- <member limittype="bitmask" noautovalidity="true"><type>VkShaderStageFlags</type> <name>subgroupSupportedStages</name><comment>Bitfield of what shader stages support subgroup operations</comment></member>
- <member limittype="bitmask" noautovalidity="true"><type>VkSubgroupFeatureFlags</type> <name>subgroupSupportedOperations</name><comment>Bitfield of what subgroup operations are supported.</comment></member>
- <member limittype="bitmask" noautovalidity="true"><type>VkBool32</type> <name>subgroupQuadOperationsInAllStages</name><comment>Flag to specify whether quad operations are available in all stages.</comment></member>
- <member limittype="noauto"><type>VkPointClippingBehavior</type> <name>pointClippingBehavior</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMultiviewViewCount</name><comment>max number of views in a subpass</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxMultiviewInstanceIndex</name><comment>max instance index for a draw in a multiview subpass</comment></member>
- <member limittype="noauto"><type>VkBool32</type> <name>protectedNoFault</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerSetDescriptors</name></member>
- <member limittype="max"><type>VkDeviceSize</type> <name>maxMemoryAllocationSize</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVulkan12Features" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>samplerMirrorClampToEdge</name></member>
- <member><type>VkBool32</type> <name>drawIndirectCount</name></member>
- <member><type>VkBool32</type> <name>storageBuffer8BitAccess</name><comment>8-bit integer variables supported in StorageBuffer</comment></member>
- <member><type>VkBool32</type> <name>uniformAndStorageBuffer8BitAccess</name><comment>8-bit integer variables supported in StorageBuffer and Uniform</comment></member>
- <member><type>VkBool32</type> <name>storagePushConstant8</name><comment>8-bit integer variables supported in PushConstant</comment></member>
- <member><type>VkBool32</type> <name>shaderBufferInt64Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderSharedInt64Atomics</name></member>
- <member><type>VkBool32</type> <name>shaderFloat16</name><comment>16-bit floats (halfs) in shaders</comment></member>
- <member><type>VkBool32</type> <name>shaderInt8</name><comment>8-bit integers in shaders</comment></member>
- <member><type>VkBool32</type> <name>descriptorIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderInputAttachmentArrayDynamicIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderUniformTexelBufferArrayDynamicIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageTexelBufferArrayDynamicIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderUniformTexelBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>shaderStorageTexelBufferArrayNonUniformIndexing</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingUniformBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingSampledImageUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingStorageImageUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingStorageBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingUniformTexelBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingStorageTexelBufferUpdateAfterBind</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingUpdateUnusedWhilePending</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingPartiallyBound</name></member>
- <member><type>VkBool32</type> <name>descriptorBindingVariableDescriptorCount</name></member>
- <member><type>VkBool32</type> <name>runtimeDescriptorArray</name></member>
- <member><type>VkBool32</type> <name>samplerFilterMinmax</name></member>
- <member><type>VkBool32</type> <name>scalarBlockLayout</name></member>
- <member><type>VkBool32</type> <name>imagelessFramebuffer</name></member>
- <member><type>VkBool32</type> <name>uniformBufferStandardLayout</name></member>
- <member><type>VkBool32</type> <name>shaderSubgroupExtendedTypes</name></member>
- <member><type>VkBool32</type> <name>separateDepthStencilLayouts</name></member>
- <member><type>VkBool32</type> <name>hostQueryReset</name></member>
- <member><type>VkBool32</type> <name>timelineSemaphore</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddress</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddressCaptureReplay</name></member>
- <member><type>VkBool32</type> <name>bufferDeviceAddressMultiDevice</name></member>
- <member><type>VkBool32</type> <name>vulkanMemoryModel</name></member>
- <member><type>VkBool32</type> <name>vulkanMemoryModelDeviceScope</name></member>
- <member><type>VkBool32</type> <name>vulkanMemoryModelAvailabilityVisibilityChains</name></member>
- <member><type>VkBool32</type> <name>shaderOutputViewportIndex</name></member>
- <member><type>VkBool32</type> <name>shaderOutputLayer</name></member>
- <member><type>VkBool32</type> <name>subgroupBroadcastDynamicId</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVulkan12Properties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkDriverId</type> <name>driverID</name></member>
- <member limittype="noauto"><type>char</type> <name>driverName</name>[<enum>VK_MAX_DRIVER_NAME_SIZE</enum>]</member>
- <member limittype="noauto"><type>char</type> <name>driverInfo</name>[<enum>VK_MAX_DRIVER_INFO_SIZE</enum>]</member>
- <member limittype="noauto"><type>VkConformanceVersion</type> <name>conformanceVersion</name></member>
- <member limittype="noauto"><type>VkShaderFloatControlsIndependence</type><name>denormBehaviorIndependence</name></member>
- <member limittype="noauto"><type>VkShaderFloatControlsIndependence</type><name>roundingModeIndependence</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat16</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat32</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat64</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormPreserveFloat16</name><comment>An implementation can preserve denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormPreserveFloat32</name><comment>An implementation can preserve denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormPreserveFloat64</name><comment>An implementation can preserve denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat16</name><comment>An implementation can flush to zero denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat32</name><comment>An implementation can flush to zero denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat64</name><comment>An implementation can flush to zero denormals</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat16</name><comment>An implementation can support RTE</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat32</name><comment>An implementation can support RTE</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat64</name><comment>An implementation can support RTE</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat16</name><comment>An implementation can support RTZ</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat32</name><comment>An implementation can support RTZ</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat64</name><comment>An implementation can support RTZ</comment></member>
- <member limittype="max"><type>uint32_t</type> <name>maxUpdateAfterBindDescriptorsInAllPools</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexingNative</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>robustBufferAccessUpdateAfterBind</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>quadDivergentImplicitLod</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindSamplers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindUniformBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindStorageBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindSampledImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindStorageImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindInputAttachments</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxPerStageUpdateAfterBindResources</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindSamplers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindUniformBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindUniformBuffersDynamic</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindStorageBuffers</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindStorageBuffersDynamic</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindSampledImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindStorageImages</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindInputAttachments</name></member>
- <member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedDepthResolveModes</name><comment>supported depth resolve modes</comment></member>
- <member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedStencilResolveModes</name><comment>supported stencil resolve modes</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>independentResolveNone</name><comment>depth and stencil resolve modes can be set independently if one of them is none</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>independentResolve</name><comment>depth and stencil resolve modes can be set independently</comment></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>filterMinmaxSingleComponentFormats</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>filterMinmaxImageComponentMapping</name></member>
- <member limittype="max"><type>uint64_t</type> <name>maxTimelineSemaphoreValueDifference</name></member>
- <member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>framebufferIntegerColorSampleCounts</name></member>
- </type>
- <type category="struct" name="VkPipelineCompilerControlCreateInfoAMD" structextends="VkGraphicsPipelineCreateInfo,VkComputePipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineCompilerControlFlagsAMD</type> <name>compilerControlFlags</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceCoherentMemoryFeaturesAMD" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>deviceCoherentMemory</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceToolPropertiesEXT" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>char</type> <name>name</name>[<enum>VK_MAX_EXTENSION_NAME_SIZE</enum>]</member>
- <member><type>char</type> <name>version</name>[<enum>VK_MAX_EXTENSION_NAME_SIZE</enum>]</member>
- <member><type>VkToolPurposeFlagsEXT</type> <name>purposes</name></member>
- <member><type>char</type> <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
- <member><type>char</type> <name>layer</name>[<enum>VK_MAX_EXTENSION_NAME_SIZE</enum>]</member>
- </type>
- <type category="struct" name="VkSamplerCustomBorderColorCreateInfoEXT" structextends="VkSamplerCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkClearColorValue</type> <name>customBorderColor</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceCustomBorderColorPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="max"><type>uint32_t</type> <name>maxCustomBorderColorSamplers</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceCustomBorderColorFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>customBorderColors</name></member>
- <member><type>VkBool32</type> <name>customBorderColorWithoutFormat</name></member>
- </type>
- <type category="struct" name="VkSamplerBorderColorComponentMappingCreateInfoEXT" structextends="VkSamplerCreateInfo">
- <member values="VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkComponentMapping</type> <name>components</name></member>
- <member><type>VkBool32</type> <name>srgb</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceBorderColorSwizzleFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>borderColorSwizzle</name></member>
- <member><type>VkBool32</type> <name>borderColorSwizzleFromImage</name></member>
- </type>
- <type category="union" name="VkDeviceOrHostAddressKHR">
- <member noautovalidity="true"><type>VkDeviceAddress</type> <name>deviceAddress</name></member>
- <member noautovalidity="true"><type>void</type>* <name>hostAddress</name></member>
- </type>
- <type category="union" name="VkDeviceOrHostAddressConstKHR">
- <member noautovalidity="true"><type>VkDeviceAddress</type> <name>deviceAddress</name></member>
- <member noautovalidity="true">const <type>void</type>* <name>hostAddress</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureGeometryTrianglesDataKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>vertexFormat</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>vertexData</name></member>
- <member><type>VkDeviceSize</type> <name>vertexStride</name></member>
- <member><type>uint32_t</type> <name>maxVertex</name></member>
- <member><type>VkIndexType</type> <name>indexType</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>indexData</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>transformData</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureGeometryAabbsDataKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>data</name></member>
- <member><type>VkDeviceSize</type> <name>stride</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureGeometryInstancesDataKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>arrayOfPointers</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>data</name></member>
- </type>
- <type category="union" name="VkAccelerationStructureGeometryDataKHR">
- <member selection="VK_GEOMETRY_TYPE_TRIANGLES_KHR"><type>VkAccelerationStructureGeometryTrianglesDataKHR</type> <name>triangles</name></member>
- <member selection="VK_GEOMETRY_TYPE_AABBS_KHR"><type>VkAccelerationStructureGeometryAabbsDataKHR</type> <name>aabbs</name></member>
- <member selection="VK_GEOMETRY_TYPE_INSTANCES_KHR"><type>VkAccelerationStructureGeometryInstancesDataKHR</type> <name>instances</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureGeometryKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkGeometryTypeKHR</type> <name>geometryType</name></member>
- <member selector="geometryType"><type>VkAccelerationStructureGeometryDataKHR</type> <name>geometry</name></member>
- <member optional="true"><type>VkGeometryFlagsKHR</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureBuildGeometryInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAccelerationStructureTypeKHR</type> <name>type</name></member>
- <member optional="true"><type>VkBuildAccelerationStructureFlagsKHR</type> <name>flags</name></member>
- <member noautovalidity="true"><type>VkBuildAccelerationStructureModeKHR</type> <name>mode</name></member>
- <member optional="true" noautovalidity="true"><type>VkAccelerationStructureKHR</type> <name>srcAccelerationStructure</name></member>
- <member optional="true" noautovalidity="true"><type>VkAccelerationStructureKHR</type> <name>dstAccelerationStructure</name></member>
- <member optional="true"><type>uint32_t</type> <name>geometryCount</name></member>
- <member len="geometryCount" optional="true">const <type>VkAccelerationStructureGeometryKHR</type>* <name>pGeometries</name></member>
- <member len="geometryCount,1" optional="true,false">const <type>VkAccelerationStructureGeometryKHR</type>* const* <name>ppGeometries</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressKHR</type> <name>scratchData</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureBuildRangeInfoKHR">
- <member><type>uint32_t</type> <name>primitiveCount</name></member>
- <member><type>uint32_t</type> <name>primitiveOffset</name></member>
- <member><type>uint32_t</type> <name>firstVertex</name></member>
- <member><type>uint32_t</type> <name>transformOffset</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkAccelerationStructureCreateFlagsKHR</type> <name>createFlags</name></member>
- <member><type>VkBuffer</type> <name>buffer</name></member>
- <member><type>VkDeviceSize</type> <name>offset</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>size</name></member>
- <member><type>VkAccelerationStructureTypeKHR</type> <name>type</name></member>
- <member optional="true"><type>VkDeviceAddress</type> <name>deviceAddress</name></member>
- </type>
- <type category="struct" name="VkAabbPositionsKHR">
- <member><type>float</type> <name>minX</name></member>
- <member><type>float</type> <name>minY</name></member>
- <member><type>float</type> <name>minZ</name></member>
- <member><type>float</type> <name>maxX</name></member>
- <member><type>float</type> <name>maxY</name></member>
- <member><type>float</type> <name>maxZ</name></member>
- </type>
- <type category="struct" name="VkAabbPositionsNV" alias="VkAabbPositionsKHR"/>
- <type category="struct" name="VkTransformMatrixKHR">
- <member><type>float</type> <name>matrix</name>[3][4]</member>
- </type>
- <type category="struct" name="VkTransformMatrixNV" alias="VkTransformMatrixKHR"/>
- <type category="struct" name="VkAccelerationStructureInstanceKHR">
- <comment>The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout.</comment>
- <member><type>VkTransformMatrixKHR</type> <name>transform</name></member>
- <member><type>uint32_t</type> <name>instanceCustomIndex</name>:24</member>
- <member><type>uint32_t</type> <name>mask</name>:8</member>
- <member><type>uint32_t</type> <name>instanceShaderBindingTableRecordOffset</name>:24</member>
- <member optional="true"><type>VkGeometryInstanceFlagsKHR</type> <name>flags</name>:8</member>
- <member><type>uint64_t</type> <name>accelerationStructureReference</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureInstanceNV" alias="VkAccelerationStructureInstanceKHR"/>
- <type category="struct" name="VkAccelerationStructureDeviceAddressInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAccelerationStructureKHR</type> <name>accelerationStructure</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureVersionInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member len="latexmath:[2 \times \mathtt{VK\_UUID\_SIZE}]" altlen="2*VK_UUID_SIZE">const <type>uint8_t</type>* <name>pVersionData</name></member>
- </type>
- <type category="struct" name="VkCopyAccelerationStructureInfoKHR">
- <member values="VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAccelerationStructureKHR</type> <name>src</name></member>
- <member><type>VkAccelerationStructureKHR</type> <name>dst</name></member>
- <member><type>VkCopyAccelerationStructureModeKHR</type> <name>mode</name></member>
- </type>
- <type category="struct" name="VkCopyAccelerationStructureToMemoryInfoKHR">
- <member values="VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkAccelerationStructureKHR</type> <name>src</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressKHR</type> <name>dst</name></member>
- <member><type>VkCopyAccelerationStructureModeKHR</type> <name>mode</name></member>
- </type>
- <type category="struct" name="VkCopyMemoryToAccelerationStructureInfoKHR">
- <member values="VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>src</name></member>
- <member><type>VkAccelerationStructureKHR</type> <name>dst</name></member>
- <member><type>VkCopyAccelerationStructureModeKHR</type> <name>mode</name></member>
- </type>
- <type category="struct" name="VkRayTracingPipelineInterfaceCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxPipelineRayPayloadSize</name></member>
- <member><type>uint32_t</type> <name>maxPipelineRayHitAttributeSize</name></member>
- </type>
- <type category="struct" name="VkPipelineLibraryCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>libraryCount</name></member>
- <member len="libraryCount">const <type>VkPipeline</type>* <name>pLibraries</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExtendedDynamicStateFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>extendedDynamicState</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExtendedDynamicState2FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>extendedDynamicState2</name></member>
- <member><type>VkBool32</type> <name>extendedDynamicState2LogicOp</name></member>
- <member><type>VkBool32</type> <name>extendedDynamicState2PatchControlPoints</name></member>
- </type>
- <type category="struct" name="VkRenderPassTransformBeginInfoQCOM" structextends="VkRenderPassBeginInfo">
- <member values="VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name><comment>Pointer to next structure</comment></member>
- <member noautovalidity="true"><type>VkSurfaceTransformFlagBitsKHR</type> <name>transform</name></member>
- </type>
- <type category="struct" name="VkCopyCommandTransformInfoQCOM" structextends="VkBufferImageCopy2KHR,VkImageBlit2KHR">
- <member values="VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkSurfaceTransformFlagBitsKHR</type> <name>transform</name></member>
- </type>
- <type category="struct" name="VkCommandBufferInheritanceRenderPassTransformInfoQCOM" structextends="VkCommandBufferInheritanceInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name><comment>Pointer to next structure</comment></member>
- <member noautovalidity="true"><type>VkSurfaceTransformFlagBitsKHR</type> <name>transform</name></member>
- <member><type>VkRect2D</type> <name>renderArea</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDiagnosticsConfigFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>diagnosticsConfig</name></member>
- </type>
- <type category="struct" name="VkDeviceDiagnosticsConfigCreateInfoNV" structextends="VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDeviceDiagnosticsConfigFlagsNV</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderZeroInitializeWorkgroupMemory</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderSubgroupUniformControlFlow</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRobustness2FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>robustBufferAccess2</name></member>
- <member><type>VkBool32</type> <name>robustImageAccess2</name></member>
- <member><type>VkBool32</type> <name>nullDescriptor</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRobustness2PropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>robustStorageBufferAccessSizeAlignment</name></member>
- <member limittype="noauto"><type>VkDeviceSize</type> <name>robustUniformBufferAccessSizeAlignment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceImageRobustnessFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>robustImageAccess</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>workgroupMemoryExplicitLayout</name></member>
- <member><type>VkBool32</type> <name>workgroupMemoryExplicitLayoutScalarBlockLayout</name></member>
- <member><type>VkBool32</type> <name>workgroupMemoryExplicitLayout8BitAccess</name></member>
- <member><type>VkBool32</type> <name>workgroupMemoryExplicitLayout16BitAccess</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePortabilitySubsetFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>constantAlphaColorBlendFactors</name></member>
- <member><type>VkBool32</type> <name>events</name></member>
- <member><type>VkBool32</type> <name>imageViewFormatReinterpretation</name></member>
- <member><type>VkBool32</type> <name>imageViewFormatSwizzle</name></member>
- <member><type>VkBool32</type> <name>imageView2DOn3DImage</name></member>
- <member><type>VkBool32</type> <name>multisampleArrayImage</name></member>
- <member><type>VkBool32</type> <name>mutableComparisonSamplers</name></member>
- <member><type>VkBool32</type> <name>pointPolygons</name></member>
- <member><type>VkBool32</type> <name>samplerMipLodBias</name></member>
- <member><type>VkBool32</type> <name>separateStencilMaskRef</name></member>
- <member><type>VkBool32</type> <name>shaderSampleRateInterpolationFunctions</name></member>
- <member><type>VkBool32</type> <name>tessellationIsolines</name></member>
- <member><type>VkBool32</type> <name>tessellationPointMode</name></member>
- <member><type>VkBool32</type> <name>triangleFans</name></member>
- <member><type>VkBool32</type> <name>vertexAttributeAccessBeyondStride</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevicePortabilitySubsetPropertiesKHR" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>minVertexInputBindingStrideAlignment</name></member>
- </type>
- <type category="struct" name="VkPhysicalDevice4444FormatsFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>formatA4R4G4B4</name></member>
- <member><type>VkBool32</type> <name>formatA4B4G4R4</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSubpassShadingFeaturesHUAWEI" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>subpassShading</name></member>
- </type>
- <type category="struct" name="VkBufferCopy2KHR">
- <member values="VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceSize</type> <name>srcOffset</name><comment>Specified in bytes</comment></member>
- <member><type>VkDeviceSize</type> <name>dstOffset</name><comment>Specified in bytes</comment></member>
- <member noautovalidity="true"><type>VkDeviceSize</type> <name>size</name><comment>Specified in bytes</comment></member>
- </type>
- <type category="struct" name="VkImageCopy2KHR">
- <member values="VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageSubresourceLayers</type> <name>srcSubresource</name></member>
- <member><type>VkOffset3D</type> <name>srcOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkImageSubresourceLayers</type> <name>dstSubresource</name></member>
- <member><type>VkOffset3D</type> <name>dstOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkExtent3D</type> <name>extent</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- </type>
- <type category="struct" name="VkImageBlit2KHR">
- <member values="VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageSubresourceLayers</type> <name>srcSubresource</name></member>
- <member><type>VkOffset3D</type> <name>srcOffsets</name>[2]<comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkImageSubresourceLayers</type> <name>dstSubresource</name></member>
- <member><type>VkOffset3D</type> <name>dstOffsets</name>[2]<comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- </type>
- <type category="struct" name="VkBufferImageCopy2KHR">
- <member values="VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceSize</type> <name>bufferOffset</name><comment>Specified in bytes</comment></member>
- <member><type>uint32_t</type> <name>bufferRowLength</name><comment>Specified in texels</comment></member>
- <member><type>uint32_t</type> <name>bufferImageHeight</name></member>
- <member><type>VkImageSubresourceLayers</type> <name>imageSubresource</name></member>
- <member><type>VkOffset3D</type> <name>imageOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- <member><type>VkExtent3D</type> <name>imageExtent</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
- </type>
- <type category="struct" name="VkImageResolve2KHR">
- <member values="VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageSubresourceLayers</type> <name>srcSubresource</name></member>
- <member><type>VkOffset3D</type> <name>srcOffset</name></member>
- <member><type>VkImageSubresourceLayers</type> <name>dstSubresource</name></member>
- <member><type>VkOffset3D</type> <name>dstOffset</name></member>
- <member><type>VkExtent3D</type> <name>extent</name></member>
- </type>
- <type category="struct" name="VkCopyBufferInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBuffer</type> <name>srcBuffer</name></member>
- <member><type>VkBuffer</type> <name>dstBuffer</name></member>
- <member><type>uint32_t</type> <name>regionCount</name></member>
- <member len="regionCount">const <type>VkBufferCopy2KHR</type>* <name>pRegions</name></member>
- </type>
- <type category="struct" name="VkCopyImageInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImage</type> <name>srcImage</name></member>
- <member><type>VkImageLayout</type> <name>srcImageLayout</name></member>
- <member><type>VkImage</type> <name>dstImage</name></member>
- <member><type>VkImageLayout</type> <name>dstImageLayout</name></member>
- <member><type>uint32_t</type> <name>regionCount</name></member>
- <member len="regionCount">const <type>VkImageCopy2KHR</type>* <name>pRegions</name></member>
- </type>
- <type category="struct" name="VkBlitImageInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImage</type> <name>srcImage</name></member>
- <member><type>VkImageLayout</type> <name>srcImageLayout</name></member>
- <member><type>VkImage</type> <name>dstImage</name></member>
- <member><type>VkImageLayout</type> <name>dstImageLayout</name></member>
- <member><type>uint32_t</type> <name>regionCount</name></member>
- <member len="regionCount">const <type>VkImageBlit2KHR</type>* <name>pRegions</name></member>
- <member><type>VkFilter</type> <name>filter</name></member>
- </type>
- <type category="struct" name="VkCopyBufferToImageInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBuffer</type> <name>srcBuffer</name></member>
- <member><type>VkImage</type> <name>dstImage</name></member>
- <member><type>VkImageLayout</type> <name>dstImageLayout</name></member>
- <member><type>uint32_t</type> <name>regionCount</name></member>
- <member len="regionCount">const <type>VkBufferImageCopy2KHR</type>* <name>pRegions</name></member>
- </type>
- <type category="struct" name="VkCopyImageToBufferInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImage</type> <name>srcImage</name></member>
- <member><type>VkImageLayout</type> <name>srcImageLayout</name></member>
- <member><type>VkBuffer</type> <name>dstBuffer</name></member>
- <member><type>uint32_t</type> <name>regionCount</name></member>
- <member len="regionCount">const <type>VkBufferImageCopy2KHR</type>* <name>pRegions</name></member>
- </type>
- <type category="struct" name="VkResolveImageInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImage</type> <name>srcImage</name></member>
- <member><type>VkImageLayout</type> <name>srcImageLayout</name></member>
- <member><type>VkImage</type> <name>dstImage</name></member>
- <member><type>VkImageLayout</type> <name>dstImageLayout</name></member>
- <member><type>uint32_t</type> <name>regionCount</name></member>
- <member len="regionCount">const <type>VkImageResolve2KHR</type>* <name>pRegions</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderImageInt64Atomics</name></member>
- <member><type>VkBool32</type> <name>sparseImageInt64Atomics</name></member>
- </type>
- <type category="struct" name="VkFragmentShadingRateAttachmentInfoKHR" structextends="VkSubpassDescription2">
- <member values="VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true">const <type>VkAttachmentReference2</type>* <name>pFragmentShadingRateAttachment</name></member>
- <member><type>VkExtent2D</type> <name>shadingRateAttachmentTexelSize</name></member>
- </type>
- <type category="struct" name="VkPipelineFragmentShadingRateStateCreateInfoKHR" structextends="VkGraphicsPipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkExtent2D</type> <name>fragmentSize</name></member>
- <member><type>VkFragmentShadingRateCombinerOpKHR</type> <name>combinerOps</name>[2]</member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentShadingRateFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>pipelineFragmentShadingRate</name></member>
- <member><type>VkBool32</type> <name>primitiveFragmentShadingRate</name></member>
- <member><type>VkBool32</type> <name>attachmentFragmentShadingRate</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentShadingRatePropertiesKHR" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="min"><type>VkExtent2D</type> <name>minFragmentShadingRateAttachmentTexelSize</name></member>
- <member limittype="max"><type>VkExtent2D</type> <name>maxFragmentShadingRateAttachmentTexelSize</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>maxFragmentShadingRateAttachmentTexelSizeAspectRatio</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>primitiveFragmentShadingRateWithMultipleViewports</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>layeredShadingRateAttachments</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateNonTrivialCombinerOps</name></member>
- <member limittype="max"><type>VkExtent2D</type> <name>maxFragmentSize</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>maxFragmentSizeAspectRatio</name></member>
- <member limittype="noauto"><type>uint32_t</type> <name>maxFragmentShadingRateCoverageSamples</name></member>
- <member limittype="max"><type>VkSampleCountFlagBits</type> <name>maxFragmentShadingRateRasterizationSamples</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateWithShaderDepthStencilWrites</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateWithSampleMask</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateWithShaderSampleMask</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateWithConservativeRasterization</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateWithFragmentShaderInterlock</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateWithCustomSampleLocations</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateStrictMultiplyCombiner</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentShadingRateKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkSampleCountFlags</type> <name>sampleCounts</name></member>
- <member><type>VkExtent2D</type> <name>fragmentSize</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderTerminateInvocation</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>fragmentShadingRateEnums</name></member>
- <member><type>VkBool32</type> <name>supersampleFragmentShadingRates</name></member>
- <member><type>VkBool32</type> <name>noInvocationFragmentShadingRates</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkSampleCountFlagBits</type> <name>maxFragmentShadingRateInvocationCount</name></member>
- </type>
- <type category="struct" name="VkPipelineFragmentShadingRateEnumStateCreateInfoNV" structextends="VkGraphicsPipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkFragmentShadingRateTypeNV</type> <name>shadingRateType</name></member>
- <member><type>VkFragmentShadingRateNV</type> <name>shadingRate</name></member>
- <member><type>VkFragmentShadingRateCombinerOpKHR</type> <name>combinerOps</name>[2]</member>
- </type>
- <type category="struct" name="VkAccelerationStructureBuildSizesInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceSize</type> <name>accelerationStructureSize</name></member>
- <member><type>VkDeviceSize</type> <name>updateScratchSize</name></member>
- <member><type>VkDeviceSize</type> <name>buildScratchSize</name></member>
- </type>
- <type category="struct" name="VkImportColorBufferGOOGLE" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE"><type>VkStructureType</type> <name>sType</name></member>
- <member><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>colorBuffer</name></member>
- </type>
- <type category="struct" name="VkImportBufferGOOGLE" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE"><type>VkStructureType</type> <name>sType</name></member>
- <member><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>buffer</name></member>
- </type>
- <type category="struct" name="VkImportPhysicalAddressGOOGLE" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE"><type>VkStructureType</type> <name>sType</name></member>
- <member><type>void</type>* <name>pNext</name></member>
- <member><type>uint64_t</type> <name>physicalAddress</name></member>
- <member><type>VkDeviceSize</type> <name>size</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>VkImageTiling</type> <name>tiling</name></member>
- <member><type>uint32_t</type> <name>tilingParameter</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>mutableDescriptorType</name></member>
- </type>
- <type category="struct" name="VkMutableDescriptorTypeListVALVE">
- <member optional="true"><type>uint32_t</type> <name>descriptorTypeCount</name></member>
- <member len="descriptorTypeCount">const <type>VkDescriptorType</type>* <name>pDescriptorTypes</name></member>
- </type>
- <type category="struct" name="VkMutableDescriptorTypeCreateInfoVALVE" structextends="VkDescriptorSetLayoutCreateInfo,VkDescriptorPoolCreateInfo">
- <member values="VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>mutableDescriptorTypeListCount</name></member>
- <member len="mutableDescriptorTypeListCount">const <type>VkMutableDescriptorTypeListVALVE</type>* <name>pMutableDescriptorTypeLists</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>vertexInputDynamicState</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceExternalMemoryRDMAFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>externalMemoryRDMA</name></member>
- </type>
- <type category="struct" name="VkVertexInputBindingDescription2EXT">
- <member values="VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>binding</name></member>
- <member><type>uint32_t</type> <name>stride</name></member>
- <member><type>VkVertexInputRate</type> <name>inputRate</name></member>
- <member><type>uint32_t</type> <name>divisor</name></member>
- </type>
- <type category="struct" name="VkVertexInputAttributeDescription2EXT">
- <member values="VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>location</name><comment>location of the shader vertex attrib</comment></member>
- <member><type>uint32_t</type> <name>binding</name><comment>Vertex buffer binding id</comment></member>
- <member><type>VkFormat</type> <name>format</name><comment>format of source data</comment></member>
- <member><type>uint32_t</type> <name>offset</name><comment>Offset of first element in bytes from base of vertex</comment></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceColorWriteEnableFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>colorWriteEnable</name></member>
- </type>
- <type category="struct" name="VkPipelineColorWriteCreateInfoEXT" structextends="VkPipelineColorBlendStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>attachmentCount</name><comment># of pAttachments</comment></member>
- <member len="attachmentCount">const <type>VkBool32</type>* <name>pColorWriteEnables</name></member>
- </type>
- <type category="struct" name="VkMemoryBarrier2KHR" structextends="VkSubpassDependency2">
- <member values="VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineStageFlags2KHR</type> <name>srcStageMask</name></member>
- <member optional="true"><type>VkAccessFlags2KHR</type> <name>srcAccessMask</name></member>
- <member optional="true"><type>VkPipelineStageFlags2KHR</type> <name>dstStageMask</name></member>
- <member optional="true"><type>VkAccessFlags2KHR</type> <name>dstAccessMask</name></member>
- </type>
- <type category="struct" name="VkImageMemoryBarrier2KHR">
- <member values="VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineStageFlags2KHR</type> <name>srcStageMask</name></member>
- <member optional="true"><type>VkAccessFlags2KHR</type> <name>srcAccessMask</name></member>
- <member optional="true"><type>VkPipelineStageFlags2KHR</type> <name>dstStageMask</name></member>
- <member optional="true"><type>VkAccessFlags2KHR</type> <name>dstAccessMask</name></member>
- <member><type>VkImageLayout</type> <name>oldLayout</name></member>
- <member><type>VkImageLayout</type> <name>newLayout</name></member>
- <member><type>uint32_t</type> <name>srcQueueFamilyIndex</name></member>
- <member><type>uint32_t</type> <name>dstQueueFamilyIndex</name></member>
- <member><type>VkImage</type> <name>image</name></member>
- <member><type>VkImageSubresourceRange</type> <name>subresourceRange</name></member>
- </type>
- <type category="struct" name="VkBufferMemoryBarrier2KHR">
- <member values="VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkPipelineStageFlags2KHR</type> <name>srcStageMask</name></member>
- <member optional="true"><type>VkAccessFlags2KHR</type> <name>srcAccessMask</name></member>
- <member optional="true"><type>VkPipelineStageFlags2KHR</type> <name>dstStageMask</name></member>
- <member optional="true"><type>VkAccessFlags2KHR</type> <name>dstAccessMask</name></member>
- <member><type>uint32_t</type> <name>srcQueueFamilyIndex</name></member>
- <member><type>uint32_t</type> <name>dstQueueFamilyIndex</name></member>
- <member><type>VkBuffer</type> <name>buffer</name></member>
- <member><type>VkDeviceSize</type> <name>offset</name></member>
- <member><type>VkDeviceSize</type> <name>size</name></member>
- </type>
- <type category="struct" name="VkDependencyInfoKHR">
- <member values="VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkDependencyFlags</type> <name>dependencyFlags</name></member>
- <member optional="true"><type>uint32_t</type> <name>memoryBarrierCount</name></member>
- <member len="memoryBarrierCount">const <type>VkMemoryBarrier2KHR</type>* <name>pMemoryBarriers</name></member>
- <member optional="true"><type>uint32_t</type> <name>bufferMemoryBarrierCount</name></member>
- <member len="bufferMemoryBarrierCount">const <type>VkBufferMemoryBarrier2KHR</type>* <name>pBufferMemoryBarriers</name></member>
- <member optional="true"><type>uint32_t</type> <name>imageMemoryBarrierCount</name></member>
- <member len="imageMemoryBarrierCount">const <type>VkImageMemoryBarrier2KHR</type>* <name>pImageMemoryBarriers</name></member>
- </type>
- <type category="struct" name="VkSemaphoreSubmitInfoKHR">
- <member values="VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkSemaphore</type> <name>semaphore</name></member>
- <member><type>uint64_t</type> <name>value</name></member>
- <member optional="true"><type>VkPipelineStageFlags2KHR</type> <name>stageMask</name></member>
- <member><type>uint32_t</type> <name>deviceIndex</name></member>
- </type>
- <type category="struct" name="VkCommandBufferSubmitInfoKHR">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkCommandBuffer</type> <name>commandBuffer</name></member>
- <member><type>uint32_t</type> <name>deviceMask</name></member>
- </type>
- <type category="struct" name="VkSubmitInfo2KHR">
- <member values="VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkSubmitFlagsKHR</type> <name>flags</name></member>
- <member optional="true"><type>uint32_t</type> <name>waitSemaphoreInfoCount</name></member>
- <member len="waitSemaphoreInfoCount">const <type>VkSemaphoreSubmitInfoKHR</type>* <name>pWaitSemaphoreInfos</name></member>
- <member optional="true"><type>uint32_t</type> <name>commandBufferInfoCount</name></member>
- <member len="commandBufferInfoCount">const <type>VkCommandBufferSubmitInfoKHR</type>* <name>pCommandBufferInfos</name></member>
- <member optional="true"><type>uint32_t</type> <name>signalSemaphoreInfoCount</name></member>
- <member len="signalSemaphoreInfoCount">const <type>VkSemaphoreSubmitInfoKHR</type>* <name>pSignalSemaphoreInfos</name></member>
- </type>
- <type category="struct" name="VkQueueFamilyCheckpointProperties2NV" structextends="VkQueueFamilyProperties2" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkPipelineStageFlags2KHR</type> <name>checkpointExecutionStageMask</name></member>
- </type>
- <type category="struct" name="VkCheckpointData2NV" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkPipelineStageFlags2KHR</type> <name>stage</name></member>
- <member noautovalidity="true"><type>void</type>* <name>pCheckpointMarker</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceSynchronization2FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>synchronization2</name></member>
- </type>
- <type category="struct" name="VkVideoQueueFamilyProperties2KHR" structextends="VkQueueFamilyProperties2">
- <member values="VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoCodecOperationFlagsKHR</type> <name>videoCodecOperations</name></member>
- </type>
- <type category="struct" name="VkVideoProfilesKHR" structextends="VkFormatProperties2,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>profileCount</name></member>
- <member>const <type>VkVideoProfileKHR</type>* <name>pProfiles</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceVideoFormatInfoKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkImageUsageFlags</type> <name>imageUsage</name></member>
- <member>const <type>VkVideoProfilesKHR</type>* <name>pVideoProfiles</name></member>
- </type>
- <type category="struct" name="VkVideoFormatPropertiesKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- </type>
- <type category="struct" name="VkVideoProfileKHR" structextends="VkQueryPoolCreateInfo,VkFormatProperties2,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoCodecOperationFlagBitsKHR</type> <name>videoCodecOperation</name></member>
- <member><type>VkVideoChromaSubsamplingFlagsKHR</type> <name>chromaSubsampling</name></member>
- <member><type>VkVideoComponentBitDepthFlagsKHR</type> <name>lumaBitDepth</name></member>
- <member><type>VkVideoComponentBitDepthFlagsKHR</type> <name>chromaBitDepth</name></member>
- </type>
- <type category="struct" name="VkVideoCapabilitiesKHR" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoCapabilityFlagsKHR</type> <name>capabilityFlags</name></member>
- <member><type>VkDeviceSize</type> <name>minBitstreamBufferOffsetAlignment</name></member>
- <member><type>VkDeviceSize</type> <name>minBitstreamBufferSizeAlignment</name></member>
- <member><type>VkExtent2D</type> <name>videoPictureExtentGranularity</name></member>
- <member><type>VkExtent2D</type> <name>minExtent</name></member>
- <member><type>VkExtent2D</type> <name>maxExtent</name></member>
- <member><type>uint32_t</type> <name>maxReferencePicturesSlotsCount</name></member>
- <member><type>uint32_t</type> <name>maxReferencePicturesActiveCount</name></member>
- </type>
- <type category="struct" name="VkVideoGetMemoryPropertiesKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>memoryBindIndex</name></member>
- <member><type>VkMemoryRequirements2</type>* <name>pMemoryRequirements</name></member>
- </type>
- <type category="struct" name="VkVideoBindMemoryKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>memoryBindIndex</name></member>
- <member><type>VkDeviceMemory</type> <name>memory</name></member>
- <member><type>VkDeviceSize</type> <name>memoryOffset</name></member>
- <member><type>VkDeviceSize</type> <name>memorySize</name></member>
- </type>
- <type category="struct" name="VkVideoPictureResourceKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkOffset2D</type> <name>codedOffset</name><comment>The offset to be used for the picture resource, currently only used in field mode</comment></member>
- <member><type>VkExtent2D</type> <name>codedExtent</name><comment>The extent to be used for the picture resource</comment></member>
- <member><type>uint32_t</type> <name>baseArrayLayer</name><comment>TThe first array layer to be accessed for the Decode or Encode Operations</comment></member>
- <member><type>VkImageView</type> <name>imageViewBinding</name><comment>The ImageView binding of the resource</comment></member>
- </type>
- <type category="struct" name="VkVideoReferenceSlotKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>int8_t</type> <name>slotIndex</name><comment>The reference slot index</comment></member>
- <member>const <type>VkVideoPictureResourceKHR</type>* <name>pPictureResource</name><comment>The reference picture resource</comment></member>
- </type>
- <type category="struct" name="VkVideoDecodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkVideoDecodeFlagsKHR</type> <name>flags</name></member>
- <member><type>VkOffset2D</type> <name>codedOffset</name></member>
- <member><type>VkExtent2D</type> <name>codedExtent</name></member>
- <member><type>VkBuffer</type> <name>srcBuffer</name></member>
- <member><type>VkDeviceSize</type> <name>srcBufferOffset</name></member>
- <member><type>VkDeviceSize</type> <name>srcBufferRange</name></member>
- <member><type>VkVideoPictureResourceKHR</type> <name>dstPictureResource</name></member>
- <member>const <type>VkVideoReferenceSlotKHR</type>* <name>pSetupReferenceSlot</name></member>
- <member optional="true"><type>uint32_t</type> <name>referenceSlotCount</name></member>
- <member len="referenceSlotCount">const <type>VkVideoReferenceSlotKHR</type>* <name>pReferenceSlots</name></member>
- </type>
- <comment>Video Decode Codec Standard specific structures</comment>
- <type category="include" name="vk_video/vulkan_video_codec_h264std.h">#include "vk_video/vulkan_video_codec_h264std.h"</type>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264ProfileIdc"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264Level"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264ChromaFormatIdc"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264PocType"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264SpsFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264ScalingLists"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264SequenceParameterSetVui"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264AspectRatioIdc"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264HrdParameters"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264SpsVuiFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264WeightedBipredIdc"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264PpsFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264SliceType"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264CabacInitIdc"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264DisableDeblockingFilterIdc"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264PictureType"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264ModificationOfPicNumsIdc"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264MemMgmtControlOp"/>
- <type category="include" name="vk_video/vulkan_video_codec_h264std_decode.h">#include "vk_video/vulkan_video_codec_h264std_decode.h"</type>
- <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264PictureInfo"/>
- <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264ReferenceInfo"/>
- <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264Mvc"/>
- <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264PictureInfoFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264ReferenceInfoFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264MvcElement"/>
- <type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264MvcElementFlags"/>
- <type category="struct" name="VkVideoDecodeH264ProfileEXT" structextends="VkVideoProfileKHR,VkQueryPoolCreateInfo,VkFormatProperties2,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>StdVideoH264ProfileIdc</type> <name>stdProfileIdc</name></member>
- <member><type>VkVideoDecodeH264PictureLayoutFlagsEXT</type> <name>pictureLayout</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH264CapabilitiesEXT" returnedonly="true" structextends="VkVideoCapabilitiesKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxLevel</name></member>
- <member><type>VkOffset2D</type> <name>fieldOffsetGranularity</name></member>
- <member><type>VkExtensionProperties</type> <name>stdExtensionVersion</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH264SessionCreateInfoEXT" structextends="VkVideoSessionCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoDecodeH264CreateFlagsEXT</type> <name>flags</name></member>
- <member>const <type>VkExtensionProperties</type>* <name>pStdExtensionVersion</name></member>
- </type>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264SequenceParameterSet"/>
- <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264PictureParameterSet"/>
- <type category="struct" name="VkVideoDecodeH264SessionParametersAddInfoEXT" structextends="VkVideoSessionParametersUpdateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>spsStdCount</name></member>
- <member len="spsStdCount" optional="true">const <type>StdVideoH264SequenceParameterSet</type>* <name>pSpsStd</name></member>
- <member><type>uint32_t</type> <name>ppsStdCount</name></member>
- <member len="ppsStdCount" optional="true">const <type>StdVideoH264PictureParameterSet</type>* <name>pPpsStd</name><comment>List of Picture Parameters associated with the spsStd, above</comment></member>
- </type>
- <type category="struct" name="VkVideoDecodeH264SessionParametersCreateInfoEXT" structextends="VkVideoSessionParametersCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxSpsStdCount</name></member>
- <member><type>uint32_t</type> <name>maxPpsStdCount</name></member>
- <member optional="true">const <type>VkVideoDecodeH264SessionParametersAddInfoEXT</type>* <name>pParametersAddInfo</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH264PictureInfoEXT" structextends="VkVideoDecodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true" noautovalidity="true">const <type>void</type>* <name>pNext</name></member>
- <member>const <type>StdVideoDecodeH264PictureInfo</type>* <name>pStdPictureInfo</name></member>
- <member><type>uint32_t</type> <name>slicesCount</name></member>
- <member len="slicesCount">const <type>uint32_t</type>* <name>pSlicesDataOffsets</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH264DpbSlotInfoEXT" structextends="VkVideoReferenceSlotKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member>const <type>StdVideoDecodeH264ReferenceInfo</type>* <name>pStdReferenceInfo</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH264MvcEXT" structextends="VkVideoDecodeH264PictureInfoEXT">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true" noautovalidity="true">const <type>void</type>*<name>pNext</name></member>
- <member>const <type>StdVideoDecodeH264Mvc</type>* <name>pStdMvc</name></member>
- </type>
- <type category="include" name="vk_video/vulkan_video_codec_h265std.h">#include "vk_video/vulkan_video_codec_h265std.h"</type>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265ProfileIdc"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265VideoParameterSet"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265SequenceParameterSet"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265PictureParameterSet"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265DecPicBufMgr"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265HrdParameters"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265VpsFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265Level"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265SpsFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265ScalingLists"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265SequenceParameterSetVui"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265PredictorPaletteEntries"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265PpsFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265SubLayerHrdParameters"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265HrdFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265SpsVuiFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265SliceType"/>
- <type requires="vk_video/vulkan_video_codec_h265std.h" name="StdVideoH265PictureType"/>
- <type category="include" name="vk_video/vulkan_video_codec_h265std_decode.h">#include "vk_video/vulkan_video_codec_h265std_decode.h"</type>
- <type requires="vk_video/vulkan_video_codec_h265std_decode.h" name="StdVideoDecodeH265PictureInfo"/>
- <type requires="vk_video/vulkan_video_codec_h265std_decode.h" name="StdVideoDecodeH265ReferenceInfo"/>
- <type requires="vk_video/vulkan_video_codec_h265std_decode.h" name="StdVideoDecodeH265PictureInfoFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std_decode.h" name="StdVideoDecodeH265ReferenceInfoFlags"/>
- <type category="struct" name="VkVideoDecodeH265ProfileEXT" structextends="VkVideoProfileKHR,VkQueryPoolCreateInfo,VkFormatProperties2,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>StdVideoH265ProfileIdc</type> <name>stdProfileIdc</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH265CapabilitiesEXT" returnedonly="true" structextends="VkVideoCapabilitiesKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxLevel</name></member>
- <member><type>VkExtensionProperties</type> <name>stdExtensionVersion</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH265SessionCreateInfoEXT" structextends="VkVideoSessionCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoDecodeH265CreateFlagsEXT</type> <name>flags</name></member>
- <member>const <type>VkExtensionProperties</type>* <name>pStdExtensionVersion</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH265SessionParametersAddInfoEXT" structextends="VkVideoSessionParametersUpdateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>spsStdCount</name></member>
- <member len="spsStdCount" optional="true">const <type>StdVideoH265SequenceParameterSet</type>* <name>pSpsStd</name></member>
- <member><type>uint32_t</type> <name>ppsStdCount</name></member>
- <member len="ppsStdCount" optional="true">const <type>StdVideoH265PictureParameterSet</type>* <name>pPpsStd</name><comment>List of Picture Parameters associated with the spsStd, above</comment></member>
- </type>
- <type category="struct" name="VkVideoDecodeH265SessionParametersCreateInfoEXT" structextends="VkVideoSessionParametersCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxSpsStdCount</name></member>
- <member><type>uint32_t</type> <name>maxPpsStdCount</name></member>
- <member optional="true">const <type>VkVideoDecodeH265SessionParametersAddInfoEXT</type>* <name>pParametersAddInfo</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH265PictureInfoEXT" structextends="VkVideoDecodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>StdVideoDecodeH265PictureInfo</type>* <name>pStdPictureInfo</name></member>
- <member><type>uint32_t</type> <name>slicesCount</name></member>
- <member len="slicesCount">const <type>uint32_t</type>* <name>pSlicesDataOffsets</name></member>
- </type>
- <type category="struct" name="VkVideoDecodeH265DpbSlotInfoEXT" structextends="VkVideoReferenceSlotKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member>const <type>StdVideoDecodeH265ReferenceInfo</type>* <name>pStdReferenceInfo</name></member>
- </type>
- <type category="struct" name="VkVideoSessionCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>queueFamilyIndex</name></member>
- <member optional="true"><type>VkVideoSessionCreateFlagsKHR</type> <name>flags</name></member>
- <member>const <type>VkVideoProfileKHR</type>* <name>pVideoProfile</name></member>
- <member><type>VkFormat</type> <name>pictureFormat</name></member>
- <member><type>VkExtent2D</type> <name>maxCodedExtent</name></member>
- <member><type>VkFormat</type> <name>referencePicturesFormat</name></member>
- <member><type>uint32_t</type> <name>maxReferencePicturesSlotsCount</name></member>
- <member><type>uint32_t</type> <name>maxReferencePicturesActiveCount</name></member>
- </type>
- <type category="struct" name="VkVideoSessionParametersCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkVideoSessionParametersKHR</type> <name>videoSessionParametersTemplate</name></member>
- <member><type>VkVideoSessionKHR</type> <name>videoSession</name></member>
- </type>
- <type category="struct" name="VkVideoSessionParametersUpdateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>updateSequenceCount</name></member>
- </type>
- <type category="struct" name="VkVideoBeginCodingInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkVideoBeginCodingFlagsKHR</type> <name>flags</name></member>
- <member><type>VkVideoCodingQualityPresetFlagsKHR</type> <name>codecQualityPreset</name></member>
- <member><type>VkVideoSessionKHR</type> <name>videoSession</name></member>
- <member optional="true"><type>VkVideoSessionParametersKHR</type> <name>videoSessionParameters</name></member>
- <member optional="true"><type>uint32_t</type> <name>referenceSlotCount</name></member>
- <member len="referenceSlotCount">const <type>VkVideoReferenceSlotKHR</type>* <name>pReferenceSlots</name></member>
- </type>
- <type category="struct" name="VkVideoEndCodingInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkVideoEndCodingFlagsKHR</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkVideoCodingControlInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkVideoCodingControlFlagsKHR</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkVideoEncodeFlagsKHR</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>qualityLevel</name></member>
- <member><type>VkExtent2D</type> <name>codedExtent</name></member>
- <member><type>VkBuffer</type> <name>dstBitstreamBuffer</name></member>
- <member><type>VkDeviceSize</type> <name>dstBitstreamBufferOffset</name></member>
- <member><type>VkDeviceSize</type> <name>dstBitstreamBufferMaxRange</name></member>
- <member><type>VkVideoPictureResourceKHR</type> <name>srcPictureResource</name></member>
- <member>const <type>VkVideoReferenceSlotKHR</type>* <name>pSetupReferenceSlot</name></member>
- <member optional="true"><type>uint32_t</type> <name>referenceSlotCount</name></member>
- <member len="referenceSlotCount">const <type>VkVideoReferenceSlotKHR</type>* <name>pReferenceSlots</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeRateControlInfoKHR" structextends="VkVideoCodingControlInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoEncodeRateControlFlagsKHR</type> <name>flags</name></member>
- <member><type>VkVideoEncodeRateControlModeFlagBitsKHR</type> <name>rateControlMode</name></member>
- <member><type>uint32_t</type> <name>averageBitrate</name></member>
- <member><type>uint16_t</type> <name>peakToAverageBitrateRatio</name></member>
- <member><type>uint16_t</type> <name>frameRateNumerator</name></member>
- <member><type>uint16_t</type> <name>frameRateDenominator</name></member>
- <member><type>uint32_t</type> <name>virtualBufferSizeInMs</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264CapabilitiesEXT" structextends="VkVideoCapabilitiesKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoEncodeH264CapabilityFlagsEXT</type> <name>flags</name></member>
- <member><type>VkVideoEncodeH264InputModeFlagsEXT</type> <name>inputModeFlags</name></member>
- <member><type>VkVideoEncodeH264OutputModeFlagsEXT</type> <name>outputModeFlags</name></member>
- <member><type>VkExtent2D</type> <name>minPictureSizeInMbs</name></member>
- <member><type>VkExtent2D</type> <name>maxPictureSizeInMbs</name></member>
- <member><type>VkExtent2D</type> <name>inputImageDataAlignment</name></member>
- <member><type>uint8_t</type> <name>maxNumL0ReferenceForP</name></member>
- <member><type>uint8_t</type> <name>maxNumL0ReferenceForB</name></member>
- <member><type>uint8_t</type> <name>maxNumL1Reference</name></member>
- <member><type>uint8_t</type> <name>qualityLevelCount</name></member>
- <member><type>VkExtensionProperties</type> <name>stdExtensionVersion</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264SessionCreateInfoEXT" structextends="VkVideoSessionCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoEncodeH264CreateFlagsEXT</type> <name>flags</name></member>
- <member><type>VkExtent2D</type> <name>maxPictureSizeInMbs</name></member>
- <member>const <type>VkExtensionProperties</type>* <name>pStdExtensionVersion</name></member>
- </type>
- <type category="include" name="vk_video/vulkan_video_codec_h264std_encode.h">#include "vk_video/vulkan_video_codec_h264std_encode.h"</type>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264SliceHeader"/>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264PictureInfo"/>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264SliceHeaderFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264RefMemMgmtCtrlOperations"/>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264PictureInfoFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264RefMgmtFlags"/>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264RefListModEntry"/>
- <type requires="vk_video/vulkan_video_codec_h264std_encode.h" name="StdVideoEncodeH264RefPicMarkingEntry"/>
- <type category="struct" name="VkVideoEncodeH264SessionParametersAddInfoEXT" structextends="VkVideoSessionParametersUpdateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>spsStdCount</name></member>
- <member len="spsStdCount" optional="true">const <type>StdVideoH264SequenceParameterSet</type>* <name>pSpsStd</name></member>
- <member><type>uint32_t</type> <name>ppsStdCount</name></member>
- <member len="ppsStdCount" optional="true">const <type>StdVideoH264PictureParameterSet</type>* <name>pPpsStd</name><comment>List of Picture Parameters associated with the spsStd, above</comment></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264SessionParametersCreateInfoEXT" structextends="VkVideoSessionParametersCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxSpsStdCount</name></member>
- <member><type>uint32_t</type> <name>maxPpsStdCount</name></member>
- <member optional="true">const <type>VkVideoEncodeH264SessionParametersAddInfoEXT</type>* <name>pParametersAddInfo</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264DpbSlotInfoEXT">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>int8_t</type> <name>slotIndex</name></member>
- <member>const <type>StdVideoEncodeH264PictureInfo</type>* <name>pStdPictureInfo</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264VclFrameInfoEXT" structextends="VkVideoEncodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint8_t</type> <name>refDefaultFinalList0EntryCount</name></member>
- <member len="refDefaultFinalList0EntryCount">const <type>VkVideoEncodeH264DpbSlotInfoEXT</type>* <name>pRefDefaultFinalList0Entries</name></member>
- <member><type>uint8_t</type> <name>refDefaultFinalList1EntryCount</name></member>
- <member len="refDefaultFinalList1EntryCount">const <type>VkVideoEncodeH264DpbSlotInfoEXT</type>* <name>pRefDefaultFinalList1Entries</name></member>
- <member><type>uint32_t</type> <name>naluSliceEntryCount</name></member>
- <member len="naluSliceEntryCount">const <type>VkVideoEncodeH264NaluSliceEXT</type>* <name>pNaluSliceEntries</name></member>
- <member>const <type>VkVideoEncodeH264DpbSlotInfoEXT</type>* <name>pCurrentPictureInfo</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264EmitPictureParametersEXT" structextends="VkVideoEncodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint8_t</type> <name>spsId</name></member>
- <member><type>VkBool32</type> <name>emitSpsEnable</name></member>
- <member><type>uint32_t</type> <name>ppsIdEntryCount</name></member>
- <member len="ppsIdEntryCount">const <type>uint8_t</type>* <name>ppsIdEntries</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264ProfileEXT" structextends="VkVideoProfileKHR,VkQueryPoolCreateInfo,VkFormatProperties2,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>StdVideoH264ProfileIdc</type> <name>stdProfileIdc</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH264NaluSliceEXT">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member>const <type>StdVideoEncodeH264SliceHeader</type>* <name>pSliceHeaderStd</name></member>
- <member><type>uint32_t</type> <name>mbCount</name></member>
- <member><type>uint8_t</type> <name>refFinalList0EntryCount</name></member>
- <member len="refFinalList0EntryCount">const <type>VkVideoEncodeH264DpbSlotInfoEXT</type>* <name>pRefFinalList0Entries</name></member>
- <member><type>uint8_t</type> <name>refFinalList1EntryCount</name></member>
- <member len="refFinalList1EntryCount">const <type>VkVideoEncodeH264DpbSlotInfoEXT</type>* <name>pRefFinalList1Entries</name></member>
- <member><type>uint32_t</type> <name>precedingNaluBytes</name></member>
- <member><type>uint8_t</type> <name>minQp</name></member>
- <member><type>uint8_t</type> <name>maxQp</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265CapabilitiesEXT" structextends="VkVideoCapabilitiesKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoEncodeH265CapabilityFlagsEXT</type> <name>flags</name></member>
- <member><type>VkVideoEncodeH265InputModeFlagsEXT</type> <name>inputModeFlags</name></member>
- <member><type>VkVideoEncodeH265OutputModeFlagsEXT</type> <name>outputModeFlags</name></member>
- <member><type>VkVideoEncodeH265CtbSizeFlagsEXT</type> <name>ctbSizes</name></member>
- <member><type>VkExtent2D</type> <name>inputImageDataAlignment</name></member>
- <member><type>uint8_t</type> <name>maxNumL0ReferenceForP</name></member>
- <member><type>uint8_t</type> <name>maxNumL0ReferenceForB</name></member>
- <member><type>uint8_t</type> <name>maxNumL1Reference</name></member>
- <member><type>uint8_t</type> <name>maxNumSubLayers</name></member>
- <member><type>uint8_t</type> <name>qualityLevelCount</name></member>
- <member><type>VkExtensionProperties</type> <name>stdExtensionVersion</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265SessionCreateInfoEXT" structextends="VkVideoSessionCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoEncodeH265CreateFlagsEXT</type> <name>flags</name></member>
- <member>const <type>VkExtensionProperties</type>* <name>pStdExtensionVersion</name></member>
- </type>
- <type category="include" name="vk_video/vulkan_video_codec_h265std_encode.h">#include "vk_video/vulkan_video_codec_h265std_encode.h"</type>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265PictureInfoFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265SliceSegmentHeader"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265PictureInfo"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265SliceHeader"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265ReferenceInfo"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265ReferenceModifications"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265SliceHeaderFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265ReferenceInfoFlags"/>
- <type requires="vk_video/vulkan_video_codec_h265std_encode.h" name="StdVideoEncodeH265ReferenceModificationFlags"/>
- <type category="struct" name="VkVideoEncodeH265SessionParametersAddInfoEXT" structextends="VkVideoSessionParametersUpdateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>vpsStdCount</name></member>
- <member len="vpsStdCount" optional="true">const <type>StdVideoH265VideoParameterSet</type>* <name>pVpsStd</name></member>
- <member><type>uint32_t</type> <name>spsStdCount</name></member>
- <member len="spsStdCount" optional="true">const <type>StdVideoH265SequenceParameterSet</type>* <name>pSpsStd</name></member>
- <member><type>uint32_t</type> <name>ppsStdCount</name></member>
- <member len="ppsStdCount" optional="true">const <type>StdVideoH265PictureParameterSet</type>* <name>pPpsStd</name><comment>List of Picture Parameters associated with the spsStd, above</comment></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265SessionParametersCreateInfoEXT" structextends="VkVideoSessionParametersCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxVpsStdCount</name></member>
- <member><type>uint32_t</type> <name>maxSpsStdCount</name></member>
- <member><type>uint32_t</type> <name>maxPpsStdCount</name></member>
- <member optional="true">const <type>VkVideoEncodeH265SessionParametersAddInfoEXT</type>* <name>pParametersAddInfo</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265VclFrameInfoEXT" structextends="VkVideoEncodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true">const <type>VkVideoEncodeH265ReferenceListsEXT</type>* <name>pReferenceFinalLists</name></member>
- <member><type>uint32_t</type> <name>naluSliceEntryCount</name></member>
- <member len="naluSliceEntryCount">const <type>VkVideoEncodeH265NaluSliceEXT</type>* <name>pNaluSliceEntries</name></member>
- <member>const <type>StdVideoEncodeH265PictureInfo</type>* <name>pCurrentPictureInfo</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265EmitPictureParametersEXT" structextends="VkVideoEncodeInfoKHR">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint8_t</type> <name>vpsId</name></member>
- <member><type>uint8_t</type> <name>spsId</name></member>
- <member><type>VkBool32</type> <name>emitVpsEnable</name></member>
- <member><type>VkBool32</type> <name>emitSpsEnable</name></member>
- <member optional="true"><type>uint32_t</type> <name>ppsIdEntryCount</name></member>
- <member len="ppsIdEntryCount">const <type>uint8_t</type>* <name>ppsIdEntries</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265NaluSliceEXT">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>ctbCount</name></member>
- <member optional="true">const <type>VkVideoEncodeH265ReferenceListsEXT</type>* <name>pReferenceFinalLists</name></member>
- <member>const <type>StdVideoEncodeH265SliceHeader</type>* <name>pSliceHeaderStd</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265ProfileEXT" structextends="VkVideoProfileKHR,VkQueryPoolCreateInfo,VkFormatProperties2,VkImageCreateInfo,VkImageViewCreateInfo,VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>StdVideoH265ProfileIdc</type> <name>stdProfileIdc</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265DpbSlotInfoEXT">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>int8_t</type> <name>slotIndex</name></member>
- <member>const <type>StdVideoEncodeH265ReferenceInfo</type>* <name>pStdReferenceInfo</name></member>
- </type>
- <type category="struct" name="VkVideoEncodeH265ReferenceListsEXT">
- <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint8_t</type> <name>referenceList0EntryCount</name></member>
- <member len="referenceList0EntryCount">const <type>VkVideoEncodeH265DpbSlotInfoEXT</type>* <name>pReferenceList0Entries</name></member>
- <member optional="true"><type>uint8_t</type> <name>referenceList1EntryCount</name></member>
- <member len="referenceList1EntryCount">const <type>VkVideoEncodeH265DpbSlotInfoEXT</type>* <name>pReferenceList1Entries</name></member>
- <member>const <type>StdVideoEncodeH265ReferenceModifications</type>* <name>pReferenceModifications</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceInheritedViewportScissorFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>inheritedViewportScissor2D</name></member>
- </type>
- <type category="struct" name="VkCommandBufferInheritanceViewportScissorInfoNV" structextends="VkCommandBufferInheritanceInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>viewportScissor2D</name></member>
- <member><type>uint32_t</type> <name>viewportDepthCount</name></member>
- <member noautovalidity="true">const <type>VkViewport</type>* <name>pViewportDepths</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>ycbcr2plane444Formats</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceProvokingVertexFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>provokingVertexLast</name></member>
- <member><type>VkBool32</type> <name>transformFeedbackPreservesProvokingVertex</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceProvokingVertexPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>provokingVertexModePerPipeline</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>transformFeedbackPreservesTriangleFanProvokingVertex</name></member>
- </type>
- <type category="struct" name="VkPipelineRasterizationProvokingVertexStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkProvokingVertexModeEXT</type> <name>provokingVertexMode</name></member>
- </type>
- <type category="struct" name="VkCuModuleCreateInfoNVX">
- <member values="VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>size_t</type> <name>dataSize</name></member>
- <member len="dataSize">const <type>void</type>* <name>pData</name></member>
- </type>
- <type category="struct" name="VkCuFunctionCreateInfoNVX">
- <member values="VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkCuModuleNVX</type> <name>module</name></member>
- <member len="null-terminated">const <type>char</type>* <name>pName</name></member>
- </type>
- <type category="struct" name="VkCuLaunchInfoNVX">
- <member values="VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkCuFunctionNVX</type> <name>function</name></member>
- <member><type>uint32_t</type> <name>gridDimX</name></member>
- <member><type>uint32_t</type> <name>gridDimY</name></member>
- <member><type>uint32_t</type> <name>gridDimZ</name></member>
- <member><type>uint32_t</type> <name>blockDimX</name></member>
- <member><type>uint32_t</type> <name>blockDimY</name></member>
- <member><type>uint32_t</type> <name>blockDimZ</name></member>
- <member><type>uint32_t</type> <name>sharedMemBytes</name></member>
- <member><type>size_t</type> <name>paramCount</name></member>
- <member len="paramCount">const <type>void</type>* const * <name>pParams</name></member>
- <member><type>size_t</type> <name>extraCount</name></member>
- <member len="extraCount">const <type>void</type>* const * <name>pExtras</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>shaderIntegerDotProduct</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct8BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct8BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct8BitMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct16BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct16BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct16BitMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct32BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct32BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct32BitMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct64BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct64BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProduct64BitMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitUnsignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitSignedAccelerated</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDrmPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>hasPrimary</name></member>
- <member limittype="bitmask"><type>VkBool32</type> <name>hasRender</name></member>
- <member limittype="noauto"><type>int64_t</type> <name>primaryMajor</name></member>
- <member limittype="noauto"><type>int64_t</type> <name>primaryMinor</name></member>
- <member limittype="noauto"><type>int64_t</type> <name>renderMajor</name></member>
- <member limittype="noauto"><type>int64_t</type> <name>renderMinor</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRayTracingMotionBlurFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>rayTracingMotionBlur</name></member>
- <member><type>VkBool32</type> <name>rayTracingMotionBlurPipelineTraceRaysIndirect</name></member>
- </type>
- <type name="VkAccelerationStructureMotionInstanceTypeNV" category="enum"/>
- <type category="struct" name="VkAccelerationStructureGeometryMotionTrianglesDataNV" structextends="VkAccelerationStructureGeometryTrianglesDataKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>vertexData</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureMotionInfoNV" structextends="VkAccelerationStructureCreateInfoKHR">
- <member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>maxInstances</name></member>
- <member optional="true"><type>VkAccelerationStructureMotionInfoFlagsNV</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkSRTDataNV">
- <member><type>float</type> <name>sx</name></member>
- <member><type>float</type> <name>a</name></member>
- <member><type>float</type> <name>b</name></member>
- <member><type>float</type> <name>pvx</name></member>
- <member><type>float</type> <name>sy</name></member>
- <member><type>float</type> <name>c</name></member>
- <member><type>float</type> <name>pvy</name></member>
- <member><type>float</type> <name>sz</name></member>
- <member><type>float</type> <name>pvz</name></member>
- <member><type>float</type> <name>qx</name></member>
- <member><type>float</type> <name>qy</name></member>
- <member><type>float</type> <name>qz</name></member>
- <member><type>float</type> <name>qw</name></member>
- <member><type>float</type> <name>tx</name></member>
- <member><type>float</type> <name>ty</name></member>
- <member><type>float</type> <name>tz</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureSRTMotionInstanceNV">
- <comment>The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout.</comment>
- <member><type>VkSRTDataNV</type> <name>transformT0</name></member>
- <member><type>VkSRTDataNV</type> <name>transformT1</name></member>
- <member><type>uint32_t</type> <name>instanceCustomIndex</name>:24</member>
- <member><type>uint32_t</type> <name>mask</name>:8</member>
- <member><type>uint32_t</type> <name>instanceShaderBindingTableRecordOffset</name>:24</member>
- <member optional="true"><type>VkGeometryInstanceFlagsKHR</type> <name>flags</name>:8</member>
- <member><type>uint64_t</type> <name>accelerationStructureReference</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureMatrixMotionInstanceNV">
- <comment>The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout.</comment>
- <member><type>VkTransformMatrixKHR</type> <name>transformT0</name></member>
- <member><type>VkTransformMatrixKHR</type> <name>transformT1</name></member>
- <member><type>uint32_t</type> <name>instanceCustomIndex</name>:24</member>
- <member><type>uint32_t</type> <name>mask</name>:8</member>
- <member><type>uint32_t</type> <name>instanceShaderBindingTableRecordOffset</name>:24</member>
- <member optional="true"><type>VkGeometryInstanceFlagsKHR</type> <name>flags</name>:8</member>
- <member><type>uint64_t</type> <name>accelerationStructureReference</name></member>
- </type>
- <type category="union" name="VkAccelerationStructureMotionInstanceDataNV">
- <member selection="VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV"><type>VkAccelerationStructureInstanceKHR</type> <name>staticInstance</name></member>
- <member selection="VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV"><type>VkAccelerationStructureMatrixMotionInstanceNV</type> <name>matrixMotionInstance</name></member>
- <member selection="VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV"><type>VkAccelerationStructureSRTMotionInstanceNV</type> <name>srtMotionInstance</name></member>
- </type>
- <type category="struct" name="VkAccelerationStructureMotionInstanceNV">
- <member><type>VkAccelerationStructureMotionInstanceTypeNV</type> <name>type</name></member>
- <member optional="true"><type>VkAccelerationStructureMotionInstanceFlagsNV</type> <name>flags</name></member>
- <member selector="type"><type>VkAccelerationStructureMotionInstanceDataNV</type> <name>data</name></member>
- </type>
- <type category="basetype">typedef <type>void</type>* <name>VkRemoteAddressNV</name>;</type>
- <type category="struct" name="VkMemoryGetRemoteAddressInfoNV">
- <member values="VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkDeviceMemory</type> <name>memory</name></member>
- <member><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
- </type>
- <type category="struct" name="VkImportMemoryBufferCollectionFUCHSIA" structextends="VkMemoryAllocateInfo">
- <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></member>
- <member><type>uint32_t</type> <name>index</name></member>
- </type>
- <type category="struct" name="VkBufferCollectionImageCreateInfoFUCHSIA" structextends="VkImageCreateInfo">
- <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></member>
- <member><type>uint32_t</type> <name>index</name></member>
- </type>
- <type category="struct" name="VkBufferCollectionBufferCreateInfoFUCHSIA" structextends="VkBufferCreateInfo">
- <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></member>
- <member><type>uint32_t</type> <name>index</name></member>
- </type>
- <type category="struct" name="VkBufferCollectionCreateInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>zx_handle_t</type> <name>collectionToken</name></member>
- </type>
- <type category="struct" name="VkBufferCollectionPropertiesFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>memoryTypeBits</name></member>
- <member><type>uint32_t</type> <name>bufferCount</name></member>
- <member><type>uint32_t</type> <name>createInfoIndex</name></member>
- <member><type>uint64_t</type> <name>sysmemPixelFormat</name></member>
- <member><type>VkFormatFeatureFlags</type> <name>formatFeatures</name></member>
- <member><type>VkSysmemColorSpaceFUCHSIA</type> <name>sysmemColorSpaceIndex</name></member>
- <member><type>VkComponentMapping</type> <name>samplerYcbcrConversionComponents</name></member>
- <member><type>VkSamplerYcbcrModelConversion</type> <name>suggestedYcbcrModel</name></member>
- <member><type>VkSamplerYcbcrRange</type> <name>suggestedYcbcrRange</name></member>
- <member><type>VkChromaLocation</type> <name>suggestedXChromaOffset</name></member>
- <member><type>VkChromaLocation</type> <name>suggestedYChromaOffset</name></member>
- </type>
- <type category="struct" name="VkBufferConstraintsInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBufferCreateInfo</type> <name>createInfo</name></member>
- <member optional="true"><type>VkFormatFeatureFlags</type> <name>requiredFormatFeatures</name></member>
- <member><type>VkBufferCollectionConstraintsInfoFUCHSIA</type> <name>bufferCollectionConstraints</name></member>
- </type>
- <type category="struct" name="VkSysmemColorSpaceFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>colorSpace</name></member>
- </type>
- <type category="struct" name="VkImageFormatConstraintsInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageCreateInfo</type> <name>imageCreateInfo</name></member>
- <member><type>VkFormatFeatureFlags</type> <name>requiredFormatFeatures</name></member>
- <member optional="true"><type>VkImageFormatConstraintsFlagsFUCHSIA</type> <name>flags</name></member>
- <member optional="true"><type>uint64_t</type> <name>sysmemPixelFormat</name></member>
- <member><type>uint32_t</type> <name>colorSpaceCount</name></member>
- <member>const <type>VkSysmemColorSpaceFUCHSIA</type>* <name>pColorSpaces</name></member>
- </type>
- <type category="struct" name="VkImageConstraintsInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>formatConstraintsCount</name></member>
- <member len="formatConstraintsCount">const <type>VkImageFormatConstraintsInfoFUCHSIA</type>* <name>pFormatConstraints</name></member>
- <member><type>VkBufferCollectionConstraintsInfoFUCHSIA</type> <name>bufferCollectionConstraints</name></member>
- <member optional="true"><type>VkImageConstraintsInfoFlagsFUCHSIA</type> <name>flags</name></member>
- </type>
- <type category="struct" name="VkBufferCollectionConstraintsInfoFUCHSIA">
- <member values="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>minBufferCount</name></member>
- <member><type>uint32_t</type> <name>maxBufferCount</name></member>
- <member><type>uint32_t</type> <name>minBufferCountForCamping</name></member>
- <member><type>uint32_t</type> <name>minBufferCountForDedicatedSlack</name></member>
- <member><type>uint32_t</type> <name>minBufferCountForSharedSlack</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>formatRgba10x6WithoutYCbCrSampler</name></member>
- </type>
- <type category="struct" name="VkFormatProperties3KHR" returnedonly="true" structextends="VkFormatProperties2">
- <member values="VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkFormatFeatureFlags2KHR</type> <name>linearTilingFeatures</name></member>
- <member optional="true"><type>VkFormatFeatureFlags2KHR</type> <name>optimalTilingFeatures</name></member>
- <member optional="true"><type>VkFormatFeatureFlags2KHR</type> <name>bufferFeatures</name></member>
- </type>
- <type category="struct" name="VkDrmFormatModifierPropertiesList2EXT" returnedonly="true" structextends="VkFormatProperties2">
- <member values="VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>uint32_t</type> <name>drmFormatModifierCount</name></member>
- <member optional="true,false" len="drmFormatModifierCount"><type>VkDrmFormatModifierProperties2EXT</type>* <name>pDrmFormatModifierProperties</name></member>
- </type>
- <type category="struct" name="VkDrmFormatModifierProperties2EXT" returnedonly="true">
- <member><type>uint64_t</type> <name>drmFormatModifier</name></member>
- <member><type>uint32_t</type> <name>drmFormatModifierPlaneCount</name></member>
- <member><type>VkFormatFeatureFlags2KHR</type> <name>drmFormatModifierTilingFeatures</name></member>
- </type>
- <type category="struct" name="VkAndroidHardwareBufferFormatProperties2ANDROID" structextends="VkAndroidHardwareBufferPropertiesANDROID" returnedonly="true">
- <member values="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkFormat</type> <name>format</name></member>
- <member><type>uint64_t</type> <name>externalFormat</name></member>
- <member><type>VkFormatFeatureFlags2KHR</type> <name>formatFeatures</name></member>
- <member><type>VkComponentMapping</type> <name>samplerYcbcrConversionComponents</name></member>
- <member><type>VkSamplerYcbcrModelConversion</type> <name>suggestedYcbcrModel</name></member>
- <member><type>VkSamplerYcbcrRange</type> <name>suggestedYcbcrRange</name></member>
- <member><type>VkChromaLocation</type> <name>suggestedXChromaOffset</name></member>
- <member><type>VkChromaLocation</type> <name>suggestedYChromaOffset</name></member>
- </type>
- <type category="struct" name="VkPipelineRenderingCreateInfoKHR" structextends="VkGraphicsPipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>viewMask</name></member>
- <member optional="true"><type>uint32_t</type> <name>colorAttachmentCount</name></member>
- <member len="colorAttachmentCount">const <type>VkFormat</type>* <name>pColorAttachmentFormats</name></member>
- <member><type>VkFormat</type> <name>depthAttachmentFormat</name></member>
- <member><type>VkFormat</type> <name>stencilAttachmentFormat</name></member>
- </type>
- <type category="struct" name="VkRenderingInfoKHR">
- <member values="VK_STRUCTURE_TYPE_RENDERING_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkRenderingFlagsKHR</type> <name>flags</name></member>
- <member><type>VkRect2D</type> <name>renderArea</name></member>
- <member><type>uint32_t</type> <name>layerCount</name></member>
- <member><type>uint32_t</type> <name>viewMask</name></member>
- <member optional="true"><type>uint32_t</type> <name>colorAttachmentCount</name></member>
- <member len="colorAttachmentCount">const <type>VkRenderingAttachmentInfoKHR</type>* <name>pColorAttachments</name></member>
- <member optional="true">const <type>VkRenderingAttachmentInfoKHR</type>* <name>pDepthAttachment</name></member>
- <member optional="true">const <type>VkRenderingAttachmentInfoKHR</type>* <name>pStencilAttachment</name></member>
- </type>
- <type category="struct" name="VkRenderingAttachmentInfoKHR">
- <member values="VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImageView</type> <name>imageView</name></member>
- <member><type>VkImageLayout</type> <name>imageLayout</name></member>
- <member optional="true"><type>VkResolveModeFlagBits</type> <name>resolveMode</name></member>
- <member optional="true"><type>VkImageView</type> <name>resolveImageView</name></member>
- <member><type>VkImageLayout</type> <name>resolveImageLayout</name></member>
- <member><type>VkAttachmentLoadOp</type> <name>loadOp</name></member>
- <member><type>VkAttachmentStoreOp</type> <name>storeOp</name></member>
- <member><type>VkClearValue</type> <name>clearValue</name></member>
- </type>
- <type category="struct" name="VkRenderingFragmentShadingRateAttachmentInfoKHR" structextends="VkRenderingInfoKHR">
- <member values="VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkImageView</type> <name>imageView</name></member>
- <member><type>VkImageLayout</type> <name>imageLayout</name></member>
- <member><type>VkExtent2D</type> <name>shadingRateAttachmentTexelSize</name></member>
- </type>
- <type category="struct" name="VkRenderingFragmentDensityMapAttachmentInfoEXT" structextends="VkRenderingInfoKHR">
- <member values="VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkImageView</type> <name>imageView</name></member>
- <member><type>VkImageLayout</type> <name>imageLayout</name></member>
- </type>
- <type category="struct" name="VkPhysicalDeviceDynamicRenderingFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
- <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>dynamicRendering</name></member>
- </type>
- <type category="struct" name="VkCommandBufferInheritanceRenderingInfoKHR" structextends="VkCommandBufferInheritanceInfo">
- <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member optional="true"><type>VkRenderingFlagsKHR</type> <name>flags</name></member>
- <member><type>uint32_t</type> <name>viewMask</name></member>
- <member><type>uint32_t</type> <name>colorAttachmentCount</name></member>
- <member len="colorAttachmentCount">const <type>VkFormat</type>* <name>pColorAttachmentFormats</name></member>
- <member><type>VkFormat</type> <name>depthAttachmentFormat</name></member>
- <member><type>VkFormat</type> <name>stencilAttachmentFormat</name></member>
- <member optional="true"><type>VkSampleCountFlagBits</type> <name>rasterizationSamples</name></member>
- </type>
- <type category="struct" name="VkAttachmentSampleCountInfoAMD" structextends="VkCommandBufferInheritanceInfo,VkGraphicsPipelineCreateInfo">
- <member values="VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>uint32_t</type> <name>colorAttachmentCount</name></member>
- <member optional="false,true" len="colorAttachmentCount">const <type>VkSampleCountFlagBits</type>* <name>pColorAttachmentSamples</name></member>
- <member optional="true"><type>VkSampleCountFlagBits</type> <name>depthStencilAttachmentSamples</name></member>
- </type>
- <type category="struct" name="VkAttachmentSampleCountInfoNV" alias="VkAttachmentSampleCountInfoAMD"/>
- <type category="struct" name="VkMultiviewPerViewAttributesInfoNVX" structextends="VkCommandBufferInheritanceInfo,VkGraphicsPipelineCreateInfo,VkRenderingInfoKHR">
- <member values="VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"><type>VkStructureType</type> <name>sType</name></member>
- <member optional="true">const <type>void</type>* <name>pNext</name></member>
- <member><type>VkBool32</type> <name>perViewAttributes</name></member>
- <member><type>VkBool32</type> <name>perViewAttributesPositionXOnly</name></member>
- </type>
- </types>
- <comment>Vulkan enumerant (token) definitions</comment>
-
- <enums name="API Constants" comment="Vulkan hardcoded constants - not an enumerated type, part of the header boilerplate">
- <enum type="uint32_t" value="256" name="VK_MAX_PHYSICAL_DEVICE_NAME_SIZE"/>
- <enum type="uint32_t" value="16" name="VK_UUID_SIZE"/>
- <enum type="uint32_t" value="8" name="VK_LUID_SIZE"/>
- <enum name="VK_LUID_SIZE_KHR" alias="VK_LUID_SIZE"/>
- <enum type="uint32_t" value="256" name="VK_MAX_EXTENSION_NAME_SIZE"/>
- <enum type="uint32_t" value="256" name="VK_MAX_DESCRIPTION_SIZE"/>
- <enum type="uint32_t" value="32" name="VK_MAX_MEMORY_TYPES"/>
- <enum type="uint32_t" value="16" name="VK_MAX_MEMORY_HEAPS" comment="The maximum number of unique memory heaps, each of which supporting 1 or more memory types"/>
- <enum type="float" value="1000.0F" name="VK_LOD_CLAMP_NONE"/>
- <enum type="uint32_t" value="(~0U)" name="VK_REMAINING_MIP_LEVELS"/>
- <enum type="uint32_t" value="(~0U)" name="VK_REMAINING_ARRAY_LAYERS"/>
- <enum type="uint64_t" value="(~0ULL)" name="VK_WHOLE_SIZE"/>
- <enum type="uint32_t" value="(~0U)" name="VK_ATTACHMENT_UNUSED"/>
- <enum type="uint32_t" value="1" name="VK_TRUE"/>
- <enum type="uint32_t" value="0" name="VK_FALSE"/>
- <enum type="uint32_t" value="(~0U)" name="VK_QUEUE_FAMILY_IGNORED"/>
- <enum type="uint32_t" value="(~1U)" name="VK_QUEUE_FAMILY_EXTERNAL"/>
- <enum name="VK_QUEUE_FAMILY_EXTERNAL_KHR" alias="VK_QUEUE_FAMILY_EXTERNAL"/>
- <enum type="uint32_t" value="(~2U)" name="VK_QUEUE_FAMILY_FOREIGN_EXT"/>
- <enum type="uint32_t" value="(~0U)" name="VK_SUBPASS_EXTERNAL"/>
- <enum type="uint32_t" value="32" name="VK_MAX_DEVICE_GROUP_SIZE"/>
- <enum name="VK_MAX_DEVICE_GROUP_SIZE_KHR" alias="VK_MAX_DEVICE_GROUP_SIZE"/>
- <enum type="uint32_t" value="256" name="VK_MAX_DRIVER_NAME_SIZE"/>
- <enum name="VK_MAX_DRIVER_NAME_SIZE_KHR" alias="VK_MAX_DRIVER_NAME_SIZE"/>
- <enum type="uint32_t" value="256" name="VK_MAX_DRIVER_INFO_SIZE"/>
- <enum name="VK_MAX_DRIVER_INFO_SIZE_KHR" alias="VK_MAX_DRIVER_INFO_SIZE"/>
- <enum type="uint32_t" value="(~0U)" name="VK_SHADER_UNUSED_KHR"/>
- <enum name="VK_SHADER_UNUSED_NV" alias="VK_SHADER_UNUSED_KHR"/>
- <enum type="uint32_t" value="16" name="VK_MAX_GLOBAL_PRIORITY_SIZE_EXT"/>
- </enums>
-
- <comment>
- Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in
- their own numeric namespaces. The "name" attribute is the C enum
- type name, and is pulled in from a type tag definition above
- (slightly clunky, but retains the type / enum distinction). "type"
- attributes of "enum" or "bitmask" indicate that these values should
- be generated inside an appropriate definition.
- </comment>
-
- <enums name="VkImageLayout" type="enum">
- <enum value="0" name="VK_IMAGE_LAYOUT_UNDEFINED" comment="Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)"/>
- <enum value="1" name="VK_IMAGE_LAYOUT_GENERAL" comment="General layout when image can be used for any kind of access"/>
- <enum value="2" name="VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" comment="Optimal layout when image is only used for color attachment read/write"/>
- <enum value="3" name="VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL" comment="Optimal layout when image is only used for depth/stencil attachment read/write"/>
- <enum value="4" name="VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" comment="Optimal layout when image is used for read only depth/stencil attachment and shader access"/>
- <enum value="5" name="VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL" comment="Optimal layout when image is used for read only shader access"/>
- <enum value="6" name="VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL" comment="Optimal layout when image is used only as source of transfer operations"/>
- <enum value="7" name="VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL" comment="Optimal layout when image is used only as destination of transfer operations"/>
- <enum value="8" name="VK_IMAGE_LAYOUT_PREINITIALIZED" comment="Initial layout used when the data is populated by the CPU"/>
- </enums>
- <enums name="VkAttachmentLoadOp" type="enum">
- <enum value="0" name="VK_ATTACHMENT_LOAD_OP_LOAD"/>
- <enum value="1" name="VK_ATTACHMENT_LOAD_OP_CLEAR"/>
- <enum value="2" name="VK_ATTACHMENT_LOAD_OP_DONT_CARE"/>
- </enums>
- <enums name="VkAttachmentStoreOp" type="enum">
- <enum value="0" name="VK_ATTACHMENT_STORE_OP_STORE"/>
- <enum value="1" name="VK_ATTACHMENT_STORE_OP_DONT_CARE"/>
- </enums>
- <enums name="VkImageType" type="enum">
- <enum value="0" name="VK_IMAGE_TYPE_1D"/>
- <enum value="1" name="VK_IMAGE_TYPE_2D"/>
- <enum value="2" name="VK_IMAGE_TYPE_3D"/>
- </enums>
- <enums name="VkImageTiling" type="enum">
- <enum value="0" name="VK_IMAGE_TILING_OPTIMAL"/>
- <enum value="1" name="VK_IMAGE_TILING_LINEAR"/>
- </enums>
- <enums name="VkImageViewType" type="enum">
- <enum value="0" name="VK_IMAGE_VIEW_TYPE_1D"/>
- <enum value="1" name="VK_IMAGE_VIEW_TYPE_2D"/>
- <enum value="2" name="VK_IMAGE_VIEW_TYPE_3D"/>
- <enum value="3" name="VK_IMAGE_VIEW_TYPE_CUBE"/>
- <enum value="4" name="VK_IMAGE_VIEW_TYPE_1D_ARRAY"/>
- <enum value="5" name="VK_IMAGE_VIEW_TYPE_2D_ARRAY"/>
- <enum value="6" name="VK_IMAGE_VIEW_TYPE_CUBE_ARRAY"/>
- </enums>
- <enums name="VkCommandBufferLevel" type="enum">
- <enum value="0" name="VK_COMMAND_BUFFER_LEVEL_PRIMARY"/>
- <enum value="1" name="VK_COMMAND_BUFFER_LEVEL_SECONDARY"/>
- </enums>
- <enums name="VkComponentSwizzle" type="enum">
- <enum value="0" name="VK_COMPONENT_SWIZZLE_IDENTITY"/>
- <enum value="1" name="VK_COMPONENT_SWIZZLE_ZERO"/>
- <enum value="2" name="VK_COMPONENT_SWIZZLE_ONE"/>
- <enum value="3" name="VK_COMPONENT_SWIZZLE_R"/>
- <enum value="4" name="VK_COMPONENT_SWIZZLE_G"/>
- <enum value="5" name="VK_COMPONENT_SWIZZLE_B"/>
- <enum value="6" name="VK_COMPONENT_SWIZZLE_A"/>
- </enums>
- <enums name="VkDescriptorType" type="enum">
- <enum value="0" name="VK_DESCRIPTOR_TYPE_SAMPLER"/>
- <enum value="1" name="VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER"/>
- <enum value="2" name="VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE"/>
- <enum value="3" name="VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"/>
- <enum value="4" name="VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER"/>
- <enum value="5" name="VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER"/>
- <enum value="6" name="VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER"/>
- <enum value="7" name="VK_DESCRIPTOR_TYPE_STORAGE_BUFFER"/>
- <enum value="8" name="VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"/>
- <enum value="9" name="VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC"/>
- <enum value="10" name="VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT"/>
- </enums>
- <enums name="VkQueryType" type="enum">
- <enum value="0" name="VK_QUERY_TYPE_OCCLUSION"/>
- <enum value="1" name="VK_QUERY_TYPE_PIPELINE_STATISTICS" comment="Optional"/>
- <enum value="2" name="VK_QUERY_TYPE_TIMESTAMP"/>
- </enums>
- <enums name="VkBorderColor" type="enum">
- <enum value="0" name="VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK"/>
- <enum value="1" name="VK_BORDER_COLOR_INT_TRANSPARENT_BLACK"/>
- <enum value="2" name="VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK"/>
- <enum value="3" name="VK_BORDER_COLOR_INT_OPAQUE_BLACK"/>
- <enum value="4" name="VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE"/>
- <enum value="5" name="VK_BORDER_COLOR_INT_OPAQUE_WHITE"/>
- </enums>
- <enums name="VkPipelineBindPoint" type="enum">
- <enum value="0" name="VK_PIPELINE_BIND_POINT_GRAPHICS"/>
- <enum value="1" name="VK_PIPELINE_BIND_POINT_COMPUTE"/>
- </enums>
- <enums name="VkPipelineCacheHeaderVersion" type="enum">
- <enum value="1" name="VK_PIPELINE_CACHE_HEADER_VERSION_ONE"/>
- </enums>
- <enums name="VkPipelineCacheCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkPrimitiveTopology" type="enum">
- <enum value="0" name="VK_PRIMITIVE_TOPOLOGY_POINT_LIST"/>
- <enum value="1" name="VK_PRIMITIVE_TOPOLOGY_LINE_LIST"/>
- <enum value="2" name="VK_PRIMITIVE_TOPOLOGY_LINE_STRIP"/>
- <enum value="3" name="VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST"/>
- <enum value="4" name="VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP"/>
- <enum value="5" name="VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN"/>
- <enum value="6" name="VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY"/>
- <enum value="7" name="VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY"/>
- <enum value="8" name="VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY"/>
- <enum value="9" name="VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY"/>
- <enum value="10" name="VK_PRIMITIVE_TOPOLOGY_PATCH_LIST"/>
- </enums>
- <enums name="VkSharingMode" type="enum">
- <enum value="0" name="VK_SHARING_MODE_EXCLUSIVE"/>
- <enum value="1" name="VK_SHARING_MODE_CONCURRENT"/>
- </enums>
- <enums name="VkIndexType" type="enum">
- <enum value="0" name="VK_INDEX_TYPE_UINT16"/>
- <enum value="1" name="VK_INDEX_TYPE_UINT32"/>
- </enums>
- <enums name="VkFilter" type="enum">
- <enum value="0" name="VK_FILTER_NEAREST"/>
- <enum value="1" name="VK_FILTER_LINEAR"/>
- </enums>
- <enums name="VkSamplerMipmapMode" type="enum">
- <enum value="0" name="VK_SAMPLER_MIPMAP_MODE_NEAREST" comment="Choose nearest mip level"/>
- <enum value="1" name="VK_SAMPLER_MIPMAP_MODE_LINEAR" comment="Linear filter between mip levels"/>
- </enums>
- <enums name="VkSamplerAddressMode" type="enum">
- <enum value="0" name="VK_SAMPLER_ADDRESS_MODE_REPEAT"/>
- <enum value="1" name="VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT"/>
- <enum value="2" name="VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE"/>
- <enum value="3" name="VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER"/>
- <comment>
- value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge
- enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not
- alias!
- </comment>
- </enums>
- <enums name="VkCompareOp" type="enum">
- <enum value="0" name="VK_COMPARE_OP_NEVER"/>
- <enum value="1" name="VK_COMPARE_OP_LESS"/>
- <enum value="2" name="VK_COMPARE_OP_EQUAL"/>
- <enum value="3" name="VK_COMPARE_OP_LESS_OR_EQUAL"/>
- <enum value="4" name="VK_COMPARE_OP_GREATER"/>
- <enum value="5" name="VK_COMPARE_OP_NOT_EQUAL"/>
- <enum value="6" name="VK_COMPARE_OP_GREATER_OR_EQUAL"/>
- <enum value="7" name="VK_COMPARE_OP_ALWAYS"/>
- </enums>
- <enums name="VkPolygonMode" type="enum">
- <enum value="0" name="VK_POLYGON_MODE_FILL"/>
- <enum value="1" name="VK_POLYGON_MODE_LINE"/>
- <enum value="2" name="VK_POLYGON_MODE_POINT"/>
- </enums>
- <enums name="VkFrontFace" type="enum">
- <enum value="0" name="VK_FRONT_FACE_COUNTER_CLOCKWISE"/>
- <enum value="1" name="VK_FRONT_FACE_CLOCKWISE"/>
- </enums>
- <enums name="VkBlendFactor" type="enum">
- <enum value="0" name="VK_BLEND_FACTOR_ZERO"/>
- <enum value="1" name="VK_BLEND_FACTOR_ONE"/>
- <enum value="2" name="VK_BLEND_FACTOR_SRC_COLOR"/>
- <enum value="3" name="VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR"/>
- <enum value="4" name="VK_BLEND_FACTOR_DST_COLOR"/>
- <enum value="5" name="VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR"/>
- <enum value="6" name="VK_BLEND_FACTOR_SRC_ALPHA"/>
- <enum value="7" name="VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA"/>
- <enum value="8" name="VK_BLEND_FACTOR_DST_ALPHA"/>
- <enum value="9" name="VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA"/>
- <enum value="10" name="VK_BLEND_FACTOR_CONSTANT_COLOR"/>
- <enum value="11" name="VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR"/>
- <enum value="12" name="VK_BLEND_FACTOR_CONSTANT_ALPHA"/>
- <enum value="13" name="VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA"/>
- <enum value="14" name="VK_BLEND_FACTOR_SRC_ALPHA_SATURATE"/>
- <enum value="15" name="VK_BLEND_FACTOR_SRC1_COLOR"/>
- <enum value="16" name="VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR"/>
- <enum value="17" name="VK_BLEND_FACTOR_SRC1_ALPHA"/>
- <enum value="18" name="VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA"/>
- </enums>
- <enums name="VkBlendOp" type="enum">
- <enum value="0" name="VK_BLEND_OP_ADD"/>
- <enum value="1" name="VK_BLEND_OP_SUBTRACT"/>
- <enum value="2" name="VK_BLEND_OP_REVERSE_SUBTRACT"/>
- <enum value="3" name="VK_BLEND_OP_MIN"/>
- <enum value="4" name="VK_BLEND_OP_MAX"/>
- </enums>
- <enums name="VkStencilOp" type="enum">
- <enum value="0" name="VK_STENCIL_OP_KEEP"/>
- <enum value="1" name="VK_STENCIL_OP_ZERO"/>
- <enum value="2" name="VK_STENCIL_OP_REPLACE"/>
- <enum value="3" name="VK_STENCIL_OP_INCREMENT_AND_CLAMP"/>
- <enum value="4" name="VK_STENCIL_OP_DECREMENT_AND_CLAMP"/>
- <enum value="5" name="VK_STENCIL_OP_INVERT"/>
- <enum value="6" name="VK_STENCIL_OP_INCREMENT_AND_WRAP"/>
- <enum value="7" name="VK_STENCIL_OP_DECREMENT_AND_WRAP"/>
- </enums>
- <enums name="VkLogicOp" type="enum">
- <enum value="0" name="VK_LOGIC_OP_CLEAR"/>
- <enum value="1" name="VK_LOGIC_OP_AND"/>
- <enum value="2" name="VK_LOGIC_OP_AND_REVERSE"/>
- <enum value="3" name="VK_LOGIC_OP_COPY"/>
- <enum value="4" name="VK_LOGIC_OP_AND_INVERTED"/>
- <enum value="5" name="VK_LOGIC_OP_NO_OP"/>
- <enum value="6" name="VK_LOGIC_OP_XOR"/>
- <enum value="7" name="VK_LOGIC_OP_OR"/>
- <enum value="8" name="VK_LOGIC_OP_NOR"/>
- <enum value="9" name="VK_LOGIC_OP_EQUIVALENT"/>
- <enum value="10" name="VK_LOGIC_OP_INVERT"/>
- <enum value="11" name="VK_LOGIC_OP_OR_REVERSE"/>
- <enum value="12" name="VK_LOGIC_OP_COPY_INVERTED"/>
- <enum value="13" name="VK_LOGIC_OP_OR_INVERTED"/>
- <enum value="14" name="VK_LOGIC_OP_NAND"/>
- <enum value="15" name="VK_LOGIC_OP_SET"/>
- </enums>
- <enums name="VkInternalAllocationType" type="enum">
- <enum value="0" name="VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE"/>
- </enums>
- <enums name="VkSystemAllocationScope" type="enum">
- <enum value="0" name="VK_SYSTEM_ALLOCATION_SCOPE_COMMAND"/>
- <enum value="1" name="VK_SYSTEM_ALLOCATION_SCOPE_OBJECT"/>
- <enum value="2" name="VK_SYSTEM_ALLOCATION_SCOPE_CACHE"/>
- <enum value="3" name="VK_SYSTEM_ALLOCATION_SCOPE_DEVICE"/>
- <enum value="4" name="VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE"/>
- </enums>
- <enums name="VkPhysicalDeviceType" type="enum">
- <enum value="0" name="VK_PHYSICAL_DEVICE_TYPE_OTHER"/>
- <enum value="1" name="VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"/>
- <enum value="2" name="VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"/>
- <enum value="3" name="VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"/>
- <enum value="4" name="VK_PHYSICAL_DEVICE_TYPE_CPU"/>
- </enums>
- <enums name="VkVertexInputRate" type="enum">
- <enum value="0" name="VK_VERTEX_INPUT_RATE_VERTEX"/>
- <enum value="1" name="VK_VERTEX_INPUT_RATE_INSTANCE"/>
- </enums>
- <enums name="VkFormat" type="enum" comment="Vulkan format definitions">
- <enum value="0" name="VK_FORMAT_UNDEFINED"/>
- <enum value="1" name="VK_FORMAT_R4G4_UNORM_PACK8"/>
- <enum value="2" name="VK_FORMAT_R4G4B4A4_UNORM_PACK16"/>
- <enum value="3" name="VK_FORMAT_B4G4R4A4_UNORM_PACK16"/>
- <enum value="4" name="VK_FORMAT_R5G6B5_UNORM_PACK16"/>
- <enum value="5" name="VK_FORMAT_B5G6R5_UNORM_PACK16"/>
- <enum value="6" name="VK_FORMAT_R5G5B5A1_UNORM_PACK16"/>
- <enum value="7" name="VK_FORMAT_B5G5R5A1_UNORM_PACK16"/>
- <enum value="8" name="VK_FORMAT_A1R5G5B5_UNORM_PACK16"/>
- <enum value="9" name="VK_FORMAT_R8_UNORM"/>
- <enum value="10" name="VK_FORMAT_R8_SNORM"/>
- <enum value="11" name="VK_FORMAT_R8_USCALED"/>
- <enum value="12" name="VK_FORMAT_R8_SSCALED"/>
- <enum value="13" name="VK_FORMAT_R8_UINT"/>
- <enum value="14" name="VK_FORMAT_R8_SINT"/>
- <enum value="15" name="VK_FORMAT_R8_SRGB"/>
- <enum value="16" name="VK_FORMAT_R8G8_UNORM"/>
- <enum value="17" name="VK_FORMAT_R8G8_SNORM"/>
- <enum value="18" name="VK_FORMAT_R8G8_USCALED"/>
- <enum value="19" name="VK_FORMAT_R8G8_SSCALED"/>
- <enum value="20" name="VK_FORMAT_R8G8_UINT"/>
- <enum value="21" name="VK_FORMAT_R8G8_SINT"/>
- <enum value="22" name="VK_FORMAT_R8G8_SRGB"/>
- <enum value="23" name="VK_FORMAT_R8G8B8_UNORM"/>
- <enum value="24" name="VK_FORMAT_R8G8B8_SNORM"/>
- <enum value="25" name="VK_FORMAT_R8G8B8_USCALED"/>
- <enum value="26" name="VK_FORMAT_R8G8B8_SSCALED"/>
- <enum value="27" name="VK_FORMAT_R8G8B8_UINT"/>
- <enum value="28" name="VK_FORMAT_R8G8B8_SINT"/>
- <enum value="29" name="VK_FORMAT_R8G8B8_SRGB"/>
- <enum value="30" name="VK_FORMAT_B8G8R8_UNORM"/>
- <enum value="31" name="VK_FORMAT_B8G8R8_SNORM"/>
- <enum value="32" name="VK_FORMAT_B8G8R8_USCALED"/>
- <enum value="33" name="VK_FORMAT_B8G8R8_SSCALED"/>
- <enum value="34" name="VK_FORMAT_B8G8R8_UINT"/>
- <enum value="35" name="VK_FORMAT_B8G8R8_SINT"/>
- <enum value="36" name="VK_FORMAT_B8G8R8_SRGB"/>
- <enum value="37" name="VK_FORMAT_R8G8B8A8_UNORM"/>
- <enum value="38" name="VK_FORMAT_R8G8B8A8_SNORM"/>
- <enum value="39" name="VK_FORMAT_R8G8B8A8_USCALED"/>
- <enum value="40" name="VK_FORMAT_R8G8B8A8_SSCALED"/>
- <enum value="41" name="VK_FORMAT_R8G8B8A8_UINT"/>
- <enum value="42" name="VK_FORMAT_R8G8B8A8_SINT"/>
- <enum value="43" name="VK_FORMAT_R8G8B8A8_SRGB"/>
- <enum value="44" name="VK_FORMAT_B8G8R8A8_UNORM"/>
- <enum value="45" name="VK_FORMAT_B8G8R8A8_SNORM"/>
- <enum value="46" name="VK_FORMAT_B8G8R8A8_USCALED"/>
- <enum value="47" name="VK_FORMAT_B8G8R8A8_SSCALED"/>
- <enum value="48" name="VK_FORMAT_B8G8R8A8_UINT"/>
- <enum value="49" name="VK_FORMAT_B8G8R8A8_SINT"/>
- <enum value="50" name="VK_FORMAT_B8G8R8A8_SRGB"/>
- <enum value="51" name="VK_FORMAT_A8B8G8R8_UNORM_PACK32"/>
- <enum value="52" name="VK_FORMAT_A8B8G8R8_SNORM_PACK32"/>
- <enum value="53" name="VK_FORMAT_A8B8G8R8_USCALED_PACK32"/>
- <enum value="54" name="VK_FORMAT_A8B8G8R8_SSCALED_PACK32"/>
- <enum value="55" name="VK_FORMAT_A8B8G8R8_UINT_PACK32"/>
- <enum value="56" name="VK_FORMAT_A8B8G8R8_SINT_PACK32"/>
- <enum value="57" name="VK_FORMAT_A8B8G8R8_SRGB_PACK32"/>
- <enum value="58" name="VK_FORMAT_A2R10G10B10_UNORM_PACK32"/>
- <enum value="59" name="VK_FORMAT_A2R10G10B10_SNORM_PACK32"/>
- <enum value="60" name="VK_FORMAT_A2R10G10B10_USCALED_PACK32"/>
- <enum value="61" name="VK_FORMAT_A2R10G10B10_SSCALED_PACK32"/>
- <enum value="62" name="VK_FORMAT_A2R10G10B10_UINT_PACK32"/>
- <enum value="63" name="VK_FORMAT_A2R10G10B10_SINT_PACK32"/>
- <enum value="64" name="VK_FORMAT_A2B10G10R10_UNORM_PACK32"/>
- <enum value="65" name="VK_FORMAT_A2B10G10R10_SNORM_PACK32"/>
- <enum value="66" name="VK_FORMAT_A2B10G10R10_USCALED_PACK32"/>
- <enum value="67" name="VK_FORMAT_A2B10G10R10_SSCALED_PACK32"/>
- <enum value="68" name="VK_FORMAT_A2B10G10R10_UINT_PACK32"/>
- <enum value="69" name="VK_FORMAT_A2B10G10R10_SINT_PACK32"/>
- <enum value="70" name="VK_FORMAT_R16_UNORM"/>
- <enum value="71" name="VK_FORMAT_R16_SNORM"/>
- <enum value="72" name="VK_FORMAT_R16_USCALED"/>
- <enum value="73" name="VK_FORMAT_R16_SSCALED"/>
- <enum value="74" name="VK_FORMAT_R16_UINT"/>
- <enum value="75" name="VK_FORMAT_R16_SINT"/>
- <enum value="76" name="VK_FORMAT_R16_SFLOAT"/>
- <enum value="77" name="VK_FORMAT_R16G16_UNORM"/>
- <enum value="78" name="VK_FORMAT_R16G16_SNORM"/>
- <enum value="79" name="VK_FORMAT_R16G16_USCALED"/>
- <enum value="80" name="VK_FORMAT_R16G16_SSCALED"/>
- <enum value="81" name="VK_FORMAT_R16G16_UINT"/>
- <enum value="82" name="VK_FORMAT_R16G16_SINT"/>
- <enum value="83" name="VK_FORMAT_R16G16_SFLOAT"/>
- <enum value="84" name="VK_FORMAT_R16G16B16_UNORM"/>
- <enum value="85" name="VK_FORMAT_R16G16B16_SNORM"/>
- <enum value="86" name="VK_FORMAT_R16G16B16_USCALED"/>
- <enum value="87" name="VK_FORMAT_R16G16B16_SSCALED"/>
- <enum value="88" name="VK_FORMAT_R16G16B16_UINT"/>
- <enum value="89" name="VK_FORMAT_R16G16B16_SINT"/>
- <enum value="90" name="VK_FORMAT_R16G16B16_SFLOAT"/>
- <enum value="91" name="VK_FORMAT_R16G16B16A16_UNORM"/>
- <enum value="92" name="VK_FORMAT_R16G16B16A16_SNORM"/>
- <enum value="93" name="VK_FORMAT_R16G16B16A16_USCALED"/>
- <enum value="94" name="VK_FORMAT_R16G16B16A16_SSCALED"/>
- <enum value="95" name="VK_FORMAT_R16G16B16A16_UINT"/>
- <enum value="96" name="VK_FORMAT_R16G16B16A16_SINT"/>
- <enum value="97" name="VK_FORMAT_R16G16B16A16_SFLOAT"/>
- <enum value="98" name="VK_FORMAT_R32_UINT"/>
- <enum value="99" name="VK_FORMAT_R32_SINT"/>
- <enum value="100" name="VK_FORMAT_R32_SFLOAT"/>
- <enum value="101" name="VK_FORMAT_R32G32_UINT"/>
- <enum value="102" name="VK_FORMAT_R32G32_SINT"/>
- <enum value="103" name="VK_FORMAT_R32G32_SFLOAT"/>
- <enum value="104" name="VK_FORMAT_R32G32B32_UINT"/>
- <enum value="105" name="VK_FORMAT_R32G32B32_SINT"/>
- <enum value="106" name="VK_FORMAT_R32G32B32_SFLOAT"/>
- <enum value="107" name="VK_FORMAT_R32G32B32A32_UINT"/>
- <enum value="108" name="VK_FORMAT_R32G32B32A32_SINT"/>
- <enum value="109" name="VK_FORMAT_R32G32B32A32_SFLOAT"/>
- <enum value="110" name="VK_FORMAT_R64_UINT"/>
- <enum value="111" name="VK_FORMAT_R64_SINT"/>
- <enum value="112" name="VK_FORMAT_R64_SFLOAT"/>
- <enum value="113" name="VK_FORMAT_R64G64_UINT"/>
- <enum value="114" name="VK_FORMAT_R64G64_SINT"/>
- <enum value="115" name="VK_FORMAT_R64G64_SFLOAT"/>
- <enum value="116" name="VK_FORMAT_R64G64B64_UINT"/>
- <enum value="117" name="VK_FORMAT_R64G64B64_SINT"/>
- <enum value="118" name="VK_FORMAT_R64G64B64_SFLOAT"/>
- <enum value="119" name="VK_FORMAT_R64G64B64A64_UINT"/>
- <enum value="120" name="VK_FORMAT_R64G64B64A64_SINT"/>
- <enum value="121" name="VK_FORMAT_R64G64B64A64_SFLOAT"/>
- <enum value="122" name="VK_FORMAT_B10G11R11_UFLOAT_PACK32"/>
- <enum value="123" name="VK_FORMAT_E5B9G9R9_UFLOAT_PACK32"/>
- <enum value="124" name="VK_FORMAT_D16_UNORM"/>
- <enum value="125" name="VK_FORMAT_X8_D24_UNORM_PACK32"/>
- <enum value="126" name="VK_FORMAT_D32_SFLOAT"/>
- <enum value="127" name="VK_FORMAT_S8_UINT"/>
- <enum value="128" name="VK_FORMAT_D16_UNORM_S8_UINT"/>
- <enum value="129" name="VK_FORMAT_D24_UNORM_S8_UINT"/>
- <enum value="130" name="VK_FORMAT_D32_SFLOAT_S8_UINT"/>
- <enum value="131" name="VK_FORMAT_BC1_RGB_UNORM_BLOCK"/>
- <enum value="132" name="VK_FORMAT_BC1_RGB_SRGB_BLOCK"/>
- <enum value="133" name="VK_FORMAT_BC1_RGBA_UNORM_BLOCK"/>
- <enum value="134" name="VK_FORMAT_BC1_RGBA_SRGB_BLOCK"/>
- <enum value="135" name="VK_FORMAT_BC2_UNORM_BLOCK"/>
- <enum value="136" name="VK_FORMAT_BC2_SRGB_BLOCK"/>
- <enum value="137" name="VK_FORMAT_BC3_UNORM_BLOCK"/>
- <enum value="138" name="VK_FORMAT_BC3_SRGB_BLOCK"/>
- <enum value="139" name="VK_FORMAT_BC4_UNORM_BLOCK"/>
- <enum value="140" name="VK_FORMAT_BC4_SNORM_BLOCK"/>
- <enum value="141" name="VK_FORMAT_BC5_UNORM_BLOCK"/>
- <enum value="142" name="VK_FORMAT_BC5_SNORM_BLOCK"/>
- <enum value="143" name="VK_FORMAT_BC6H_UFLOAT_BLOCK"/>
- <enum value="144" name="VK_FORMAT_BC6H_SFLOAT_BLOCK"/>
- <enum value="145" name="VK_FORMAT_BC7_UNORM_BLOCK"/>
- <enum value="146" name="VK_FORMAT_BC7_SRGB_BLOCK"/>
- <enum value="147" name="VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK"/>
- <enum value="148" name="VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK"/>
- <enum value="149" name="VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"/>
- <enum value="150" name="VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"/>
- <enum value="151" name="VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"/>
- <enum value="152" name="VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"/>
- <enum value="153" name="VK_FORMAT_EAC_R11_UNORM_BLOCK"/>
- <enum value="154" name="VK_FORMAT_EAC_R11_SNORM_BLOCK"/>
- <enum value="155" name="VK_FORMAT_EAC_R11G11_UNORM_BLOCK"/>
- <enum value="156" name="VK_FORMAT_EAC_R11G11_SNORM_BLOCK"/>
- <enum value="157" name="VK_FORMAT_ASTC_4x4_UNORM_BLOCK"/>
- <enum value="158" name="VK_FORMAT_ASTC_4x4_SRGB_BLOCK"/>
- <enum value="159" name="VK_FORMAT_ASTC_5x4_UNORM_BLOCK"/>
- <enum value="160" name="VK_FORMAT_ASTC_5x4_SRGB_BLOCK"/>
- <enum value="161" name="VK_FORMAT_ASTC_5x5_UNORM_BLOCK"/>
- <enum value="162" name="VK_FORMAT_ASTC_5x5_SRGB_BLOCK"/>
- <enum value="163" name="VK_FORMAT_ASTC_6x5_UNORM_BLOCK"/>
- <enum value="164" name="VK_FORMAT_ASTC_6x5_SRGB_BLOCK"/>
- <enum value="165" name="VK_FORMAT_ASTC_6x6_UNORM_BLOCK"/>
- <enum value="166" name="VK_FORMAT_ASTC_6x6_SRGB_BLOCK"/>
- <enum value="167" name="VK_FORMAT_ASTC_8x5_UNORM_BLOCK"/>
- <enum value="168" name="VK_FORMAT_ASTC_8x5_SRGB_BLOCK"/>
- <enum value="169" name="VK_FORMAT_ASTC_8x6_UNORM_BLOCK"/>
- <enum value="170" name="VK_FORMAT_ASTC_8x6_SRGB_BLOCK"/>
- <enum value="171" name="VK_FORMAT_ASTC_8x8_UNORM_BLOCK"/>
- <enum value="172" name="VK_FORMAT_ASTC_8x8_SRGB_BLOCK"/>
- <enum value="173" name="VK_FORMAT_ASTC_10x5_UNORM_BLOCK"/>
- <enum value="174" name="VK_FORMAT_ASTC_10x5_SRGB_BLOCK"/>
- <enum value="175" name="VK_FORMAT_ASTC_10x6_UNORM_BLOCK"/>
- <enum value="176" name="VK_FORMAT_ASTC_10x6_SRGB_BLOCK"/>
- <enum value="177" name="VK_FORMAT_ASTC_10x8_UNORM_BLOCK"/>
- <enum value="178" name="VK_FORMAT_ASTC_10x8_SRGB_BLOCK"/>
- <enum value="179" name="VK_FORMAT_ASTC_10x10_UNORM_BLOCK"/>
- <enum value="180" name="VK_FORMAT_ASTC_10x10_SRGB_BLOCK"/>
- <enum value="181" name="VK_FORMAT_ASTC_12x10_UNORM_BLOCK"/>
- <enum value="182" name="VK_FORMAT_ASTC_12x10_SRGB_BLOCK"/>
- <enum value="183" name="VK_FORMAT_ASTC_12x12_UNORM_BLOCK"/>
- <enum value="184" name="VK_FORMAT_ASTC_12x12_SRGB_BLOCK"/>
- </enums>
- <enums name="VkStructureType" type="enum" comment="Structure type enumerant">
- <enum value="0" name="VK_STRUCTURE_TYPE_APPLICATION_INFO"/>
- <enum value="1" name="VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"/>
- <enum value="2" name="VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"/>
- <enum value="3" name="VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"/>
- <enum value="4" name="VK_STRUCTURE_TYPE_SUBMIT_INFO"/>
- <enum value="5" name="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"/>
- <enum value="6" name="VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"/>
- <enum value="7" name="VK_STRUCTURE_TYPE_BIND_SPARSE_INFO"/>
- <enum value="8" name="VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"/>
- <enum value="9" name="VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"/>
- <enum value="10" name="VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"/>
- <enum value="11" name="VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"/>
- <enum value="12" name="VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"/>
- <enum value="13" name="VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"/>
- <enum value="14" name="VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"/>
- <enum value="15" name="VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"/>
- <enum value="16" name="VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO"/>
- <enum value="17" name="VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"/>
- <enum value="18" name="VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"/>
- <enum value="19" name="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"/>
- <enum value="20" name="VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"/>
- <enum value="21" name="VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"/>
- <enum value="22" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"/>
- <enum value="23" name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"/>
- <enum value="24" name="VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"/>
- <enum value="25" name="VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"/>
- <enum value="26" name="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"/>
- <enum value="27" name="VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"/>
- <enum value="28" name="VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"/>
- <enum value="29" name="VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"/>
- <enum value="30" name="VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"/>
- <enum value="31" name="VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"/>
- <enum value="32" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"/>
- <enum value="33" name="VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"/>
- <enum value="34" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"/>
- <enum value="35" name="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"/>
- <enum value="36" name="VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"/>
- <enum value="37" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"/>
- <enum value="38" name="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"/>
- <enum value="39" name="VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"/>
- <enum value="40" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"/>
- <enum value="41" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"/>
- <enum value="42" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"/>
- <enum value="43" name="VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"/>
- <enum value="44" name="VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"/>
- <enum value="45" name="VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"/>
- <enum value="46" name="VK_STRUCTURE_TYPE_MEMORY_BARRIER"/>
- <enum value="47" name="VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO" comment="Reserved for internal use by the loader, layers, and ICDs"/>
- <enum value="48" name="VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO" comment="Reserved for internal use by the loader, layers, and ICDs"/>
- </enums>
- <enums name="VkSubpassContents" type="enum">
- <enum value="0" name="VK_SUBPASS_CONTENTS_INLINE"/>
- <enum value="1" name="VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS"/>
- </enums>
- <enums name="VkResult" type="enum" comment="API result codes">
- <comment>Return codes (positive values)</comment>
- <enum value="0" name="VK_SUCCESS" comment="Command completed successfully"/>
- <enum value="1" name="VK_NOT_READY" comment="A fence or query has not yet completed"/>
- <enum value="2" name="VK_TIMEOUT" comment="A wait operation has not completed in the specified time"/>
- <enum value="3" name="VK_EVENT_SET" comment="An event is signaled"/>
- <enum value="4" name="VK_EVENT_RESET" comment="An event is unsignaled"/>
- <enum value="5" name="VK_INCOMPLETE" comment="A return array was too small for the result"/>
- <comment>Error codes (negative values)</comment>
- <enum value="-1" name="VK_ERROR_OUT_OF_HOST_MEMORY" comment="A host memory allocation has failed"/>
- <enum value="-2" name="VK_ERROR_OUT_OF_DEVICE_MEMORY" comment="A device memory allocation has failed"/>
- <enum value="-3" name="VK_ERROR_INITIALIZATION_FAILED" comment="Initialization of a object has failed"/>
- <enum value="-4" name="VK_ERROR_DEVICE_LOST" comment="The logical device has been lost. See <<devsandqueues-lost-device>>"/>
- <enum value="-5" name="VK_ERROR_MEMORY_MAP_FAILED" comment="Mapping of a memory object has failed"/>
- <enum value="-6" name="VK_ERROR_LAYER_NOT_PRESENT" comment="Layer specified does not exist"/>
- <enum value="-7" name="VK_ERROR_EXTENSION_NOT_PRESENT" comment="Extension specified does not exist"/>
- <enum value="-8" name="VK_ERROR_FEATURE_NOT_PRESENT" comment="Requested feature is not available on this device"/>
- <enum value="-9" name="VK_ERROR_INCOMPATIBLE_DRIVER" comment="Unable to find a Vulkan driver"/>
- <enum value="-10" name="VK_ERROR_TOO_MANY_OBJECTS" comment="Too many objects of the type have already been created"/>
- <enum value="-11" name="VK_ERROR_FORMAT_NOT_SUPPORTED" comment="Requested format is not supported on this device"/>
- <enum value="-12" name="VK_ERROR_FRAGMENTED_POOL" comment="A requested pool allocation has failed due to fragmentation of the pool's memory"/>
- <enum value="-13" name="VK_ERROR_UNKNOWN" comment="An unknown error has occurred, due to an implementation or application bug"/>
- <unused start="-14" comment="This is the next unused available error code (negative value)"/>
- </enums>
- <enums name="VkDynamicState" type="enum">
- <enum value="0" name="VK_DYNAMIC_STATE_VIEWPORT"/>
- <enum value="1" name="VK_DYNAMIC_STATE_SCISSOR"/>
- <enum value="2" name="VK_DYNAMIC_STATE_LINE_WIDTH"/>
- <enum value="3" name="VK_DYNAMIC_STATE_DEPTH_BIAS"/>
- <enum value="4" name="VK_DYNAMIC_STATE_BLEND_CONSTANTS"/>
- <enum value="5" name="VK_DYNAMIC_STATE_DEPTH_BOUNDS"/>
- <enum value="6" name="VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK"/>
- <enum value="7" name="VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"/>
- <enum value="8" name="VK_DYNAMIC_STATE_STENCIL_REFERENCE"/>
- </enums>
- <enums name="VkDescriptorUpdateTemplateType" type="enum">
- <enum value="0" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET" comment="Create descriptor update template for descriptor set updates"/>
- </enums>
- <enums name="VkObjectType" type="enum" comment="Enums to track objects of various types - also see objtypeenum attributes on type tags">
- <enum value="0" name="VK_OBJECT_TYPE_UNKNOWN"/>
- <enum value="1" name="VK_OBJECT_TYPE_INSTANCE"/>
- <enum value="2" name="VK_OBJECT_TYPE_PHYSICAL_DEVICE"/>
- <enum value="3" name="VK_OBJECT_TYPE_DEVICE"/>
- <enum value="4" name="VK_OBJECT_TYPE_QUEUE"/>
- <enum value="5" name="VK_OBJECT_TYPE_SEMAPHORE"/>
- <enum value="6" name="VK_OBJECT_TYPE_COMMAND_BUFFER"/>
- <enum value="7" name="VK_OBJECT_TYPE_FENCE"/>
- <enum value="8" name="VK_OBJECT_TYPE_DEVICE_MEMORY"/>
- <enum value="9" name="VK_OBJECT_TYPE_BUFFER"/>
- <enum value="10" name="VK_OBJECT_TYPE_IMAGE"/>
- <enum value="11" name="VK_OBJECT_TYPE_EVENT"/>
- <enum value="12" name="VK_OBJECT_TYPE_QUERY_POOL"/>
- <enum value="13" name="VK_OBJECT_TYPE_BUFFER_VIEW"/>
- <enum value="14" name="VK_OBJECT_TYPE_IMAGE_VIEW"/>
- <enum value="15" name="VK_OBJECT_TYPE_SHADER_MODULE"/>
- <enum value="16" name="VK_OBJECT_TYPE_PIPELINE_CACHE"/>
- <enum value="17" name="VK_OBJECT_TYPE_PIPELINE_LAYOUT"/>
- <enum value="18" name="VK_OBJECT_TYPE_RENDER_PASS"/>
- <enum value="19" name="VK_OBJECT_TYPE_PIPELINE"/>
- <enum value="20" name="VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"/>
- <enum value="21" name="VK_OBJECT_TYPE_SAMPLER"/>
- <enum value="22" name="VK_OBJECT_TYPE_DESCRIPTOR_POOL"/>
- <enum value="23" name="VK_OBJECT_TYPE_DESCRIPTOR_SET"/>
- <enum value="24" name="VK_OBJECT_TYPE_FRAMEBUFFER"/>
- <enum value="25" name="VK_OBJECT_TYPE_COMMAND_POOL"/>
- </enums>
-
- <comment>Flags</comment>
- <enums name="VkQueueFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_QUEUE_GRAPHICS_BIT" comment="Queue supports graphics operations"/>
- <enum bitpos="1" name="VK_QUEUE_COMPUTE_BIT" comment="Queue supports compute operations"/>
- <enum bitpos="2" name="VK_QUEUE_TRANSFER_BIT" comment="Queue supports transfer operations"/>
- <enum bitpos="3" name="VK_QUEUE_SPARSE_BINDING_BIT" comment="Queue supports sparse resource memory management operations"/>
- </enums>
- <enums name="VkCullModeFlagBits" type="bitmask">
- <enum value="0" name="VK_CULL_MODE_NONE"/>
- <enum bitpos="0" name="VK_CULL_MODE_FRONT_BIT"/>
- <enum bitpos="1" name="VK_CULL_MODE_BACK_BIT"/>
- <enum value="0x00000003" name="VK_CULL_MODE_FRONT_AND_BACK"/>
- </enums>
- <enums name="VkRenderPassCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkDeviceQueueCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkMemoryPropertyFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT" comment="If otherwise stated, then allocate memory on device"/>
- <enum bitpos="1" name="VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT" comment="Memory is mappable by host"/>
- <enum bitpos="2" name="VK_MEMORY_PROPERTY_HOST_COHERENT_BIT" comment="Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"/>
- <enum bitpos="3" name="VK_MEMORY_PROPERTY_HOST_CACHED_BIT" comment="Memory will be cached by the host"/>
- <enum bitpos="4" name="VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT" comment="Memory may be allocated by the driver when it is required"/>
- </enums>
- <enums name="VkMemoryHeapFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_MEMORY_HEAP_DEVICE_LOCAL_BIT" comment="If set, heap represents device memory"/>
- </enums>
- <enums name="VkAccessFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_ACCESS_INDIRECT_COMMAND_READ_BIT" comment="Controls coherency of indirect command reads"/>
- <enum bitpos="1" name="VK_ACCESS_INDEX_READ_BIT" comment="Controls coherency of index reads"/>
- <enum bitpos="2" name="VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT" comment="Controls coherency of vertex attribute reads"/>
- <enum bitpos="3" name="VK_ACCESS_UNIFORM_READ_BIT" comment="Controls coherency of uniform buffer reads"/>
- <enum bitpos="4" name="VK_ACCESS_INPUT_ATTACHMENT_READ_BIT" comment="Controls coherency of input attachment reads"/>
- <enum bitpos="5" name="VK_ACCESS_SHADER_READ_BIT" comment="Controls coherency of shader reads"/>
- <enum bitpos="6" name="VK_ACCESS_SHADER_WRITE_BIT" comment="Controls coherency of shader writes"/>
- <enum bitpos="7" name="VK_ACCESS_COLOR_ATTACHMENT_READ_BIT" comment="Controls coherency of color attachment reads"/>
- <enum bitpos="8" name="VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT" comment="Controls coherency of color attachment writes"/>
- <enum bitpos="9" name="VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT" comment="Controls coherency of depth/stencil attachment reads"/>
- <enum bitpos="10" name="VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT" comment="Controls coherency of depth/stencil attachment writes"/>
- <enum bitpos="11" name="VK_ACCESS_TRANSFER_READ_BIT" comment="Controls coherency of transfer reads"/>
- <enum bitpos="12" name="VK_ACCESS_TRANSFER_WRITE_BIT" comment="Controls coherency of transfer writes"/>
- <enum bitpos="13" name="VK_ACCESS_HOST_READ_BIT" comment="Controls coherency of host reads"/>
- <enum bitpos="14" name="VK_ACCESS_HOST_WRITE_BIT" comment="Controls coherency of host writes"/>
- <enum bitpos="15" name="VK_ACCESS_MEMORY_READ_BIT" comment="Controls coherency of memory reads"/>
- <enum bitpos="16" name="VK_ACCESS_MEMORY_WRITE_BIT" comment="Controls coherency of memory writes"/>
- </enums>
- <enums name="VkBufferUsageFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_BUFFER_USAGE_TRANSFER_SRC_BIT" comment="Can be used as a source of transfer operations"/>
- <enum bitpos="1" name="VK_BUFFER_USAGE_TRANSFER_DST_BIT" comment="Can be used as a destination of transfer operations"/>
- <enum bitpos="2" name="VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT" comment="Can be used as TBO"/>
- <enum bitpos="3" name="VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT" comment="Can be used as IBO"/>
- <enum bitpos="4" name="VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT" comment="Can be used as UBO"/>
- <enum bitpos="5" name="VK_BUFFER_USAGE_STORAGE_BUFFER_BIT" comment="Can be used as SSBO"/>
- <enum bitpos="6" name="VK_BUFFER_USAGE_INDEX_BUFFER_BIT" comment="Can be used as source of fixed-function index fetch (index buffer)"/>
- <enum bitpos="7" name="VK_BUFFER_USAGE_VERTEX_BUFFER_BIT" comment="Can be used as source of fixed-function vertex fetch (VBO)"/>
- <enum bitpos="8" name="VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT" comment="Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"/>
- </enums>
- <enums name="VkBufferCreateFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_BUFFER_CREATE_SPARSE_BINDING_BIT" comment="Buffer should support sparse backing"/>
- <enum bitpos="1" name="VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" comment="Buffer should support sparse backing with partial residency"/>
- <enum bitpos="2" name="VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" comment="Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers"/>
- </enums>
- <enums name="VkShaderStageFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_SHADER_STAGE_VERTEX_BIT"/>
- <enum bitpos="1" name="VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"/>
- <enum bitpos="2" name="VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"/>
- <enum bitpos="3" name="VK_SHADER_STAGE_GEOMETRY_BIT"/>
- <enum bitpos="4" name="VK_SHADER_STAGE_FRAGMENT_BIT"/>
- <enum bitpos="5" name="VK_SHADER_STAGE_COMPUTE_BIT"/>
- <enum value="0x0000001F" name="VK_SHADER_STAGE_ALL_GRAPHICS"/>
- <enum value="0x7FFFFFFF" name="VK_SHADER_STAGE_ALL"/>
- </enums>
- <enums name="VkImageUsageFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_IMAGE_USAGE_TRANSFER_SRC_BIT" comment="Can be used as a source of transfer operations"/>
- <enum bitpos="1" name="VK_IMAGE_USAGE_TRANSFER_DST_BIT" comment="Can be used as a destination of transfer operations"/>
- <enum bitpos="2" name="VK_IMAGE_USAGE_SAMPLED_BIT" comment="Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"/>
- <enum bitpos="3" name="VK_IMAGE_USAGE_STORAGE_BIT" comment="Can be used as storage image (STORAGE_IMAGE descriptor type)"/>
- <enum bitpos="4" name="VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" comment="Can be used as framebuffer color attachment"/>
- <enum bitpos="5" name="VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" comment="Can be used as framebuffer depth/stencil attachment"/>
- <enum bitpos="6" name="VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT" comment="Image data not needed outside of rendering"/>
- <enum bitpos="7" name="VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" comment="Can be used as framebuffer input attachment"/>
- </enums>
- <enums name="VkImageCreateFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_IMAGE_CREATE_SPARSE_BINDING_BIT" comment="Image should support sparse backing"/>
- <enum bitpos="1" name="VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" comment="Image should support sparse backing with partial residency"/>
- <enum bitpos="2" name="VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" comment="Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images"/>
- <enum bitpos="3" name="VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT" comment="Allows image views to have different format than the base image"/>
- <enum bitpos="4" name="VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT" comment="Allows creating image views with cube type from the created image"/>
- </enums>
- <enums name="VkImageViewCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkSamplerCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkPipelineCreateFlagBits" type="bitmask" comment="Note that the gap at bitpos 10 is unused, and can be reserved">
- <enum bitpos="0" name="VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"/>
- <enum bitpos="1" name="VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"/>
- <enum bitpos="2" name="VK_PIPELINE_CREATE_DERIVATIVE_BIT"/>
- </enums>
- <enums name="VkPipelineShaderStageCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkColorComponentFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_COLOR_COMPONENT_R_BIT"/>
- <enum bitpos="1" name="VK_COLOR_COMPONENT_G_BIT"/>
- <enum bitpos="2" name="VK_COLOR_COMPONENT_B_BIT"/>
- <enum bitpos="3" name="VK_COLOR_COMPONENT_A_BIT"/>
- </enums>
- <enums name="VkFenceCreateFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_FENCE_CREATE_SIGNALED_BIT"/>
- </enums>
- <enums name="VkSemaphoreCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkFormatFeatureFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT" comment="Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"/>
- <enum bitpos="1" name="VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT" comment="Format can be used for storage images (STORAGE_IMAGE descriptor type)"/>
- <enum bitpos="2" name="VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" comment="Format supports atomic operations in case it is used for storage images"/>
- <enum bitpos="3" name="VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT" comment="Format can be used for uniform texel buffers (TBOs)"/>
- <enum bitpos="4" name="VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT" comment="Format can be used for storage texel buffers (IBOs)"/>
- <enum bitpos="5" name="VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT" comment="Format supports atomic operations in case it is used for storage texel buffers"/>
- <enum bitpos="6" name="VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT" comment="Format can be used for vertex buffers (VBOs)"/>
- <enum bitpos="7" name="VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" comment="Format can be used for color attachment images"/>
- <enum bitpos="8" name="VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" comment="Format supports blending in case it is used for color attachment images"/>
- <enum bitpos="9" name="VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" comment="Format can be used for depth/stencil attachment images"/>
- <enum bitpos="10" name="VK_FORMAT_FEATURE_BLIT_SRC_BIT" comment="Format can be used as the source image of blits with vkCmdBlitImage"/>
- <enum bitpos="11" name="VK_FORMAT_FEATURE_BLIT_DST_BIT" comment="Format can be used as the destination image of blits with vkCmdBlitImage"/>
- <enum bitpos="12" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" comment="Format can be filtered with VK_FILTER_LINEAR when being sampled"/>
- </enums>
- <enums name="VkQueryControlFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_QUERY_CONTROL_PRECISE_BIT" comment="Require precise results to be collected by the query"/>
- </enums>
- <enums name="VkQueryResultFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_QUERY_RESULT_64_BIT" comment="Results of the queries are written to the destination buffer as 64-bit values"/>
- <enum bitpos="1" name="VK_QUERY_RESULT_WAIT_BIT" comment="Results of the queries are waited on before proceeding with the result copy"/>
- <enum bitpos="2" name="VK_QUERY_RESULT_WITH_AVAILABILITY_BIT" comment="Besides the results of the query, the availability of the results is also written"/>
- <enum bitpos="3" name="VK_QUERY_RESULT_PARTIAL_BIT" comment="Copy the partial results of the query even if the final results are not available"/>
- </enums>
- <enums name="VkCommandBufferUsageFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"/>
- <enum bitpos="1" name="VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"/>
- <enum bitpos="2" name="VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT" comment="Command buffer may be submitted/executed more than once simultaneously"/>
- </enums>
- <enums name="VkQueryPipelineStatisticFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT" comment="Optional"/>
- <enum bitpos="1" name="VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT" comment="Optional"/>
- <enum bitpos="2" name="VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT" comment="Optional"/>
- <enum bitpos="3" name="VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT" comment="Optional"/>
- <enum bitpos="4" name="VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT" comment="Optional"/>
- <enum bitpos="5" name="VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT" comment="Optional"/>
- <enum bitpos="6" name="VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT" comment="Optional"/>
- <enum bitpos="7" name="VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT" comment="Optional"/>
- <enum bitpos="8" name="VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT" comment="Optional"/>
- <enum bitpos="9" name="VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT" comment="Optional"/>
- <enum bitpos="10" name="VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT" comment="Optional"/>
- </enums>
- <enums name="VkImageAspectFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_IMAGE_ASPECT_COLOR_BIT"/>
- <enum bitpos="1" name="VK_IMAGE_ASPECT_DEPTH_BIT"/>
- <enum bitpos="2" name="VK_IMAGE_ASPECT_STENCIL_BIT"/>
- <enum bitpos="3" name="VK_IMAGE_ASPECT_METADATA_BIT"/>
- </enums>
- <enums name="VkSparseImageFormatFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT" comment="Image uses a single mip tail region for all array layers"/>
- <enum bitpos="1" name="VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT" comment="Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."/>
- <enum bitpos="2" name="VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT" comment="Image uses a non-standard sparse image block dimensions"/>
- </enums>
- <enums name="VkSparseMemoryBindFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_SPARSE_MEMORY_BIND_METADATA_BIT" comment="Operation binds resource metadata to memory"/>
- </enums>
- <enums name="VkPipelineStageFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT" comment="Before subsequent commands are processed"/>
- <enum bitpos="1" name="VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT" comment="Draw/DispatchIndirect command fetch"/>
- <enum bitpos="2" name="VK_PIPELINE_STAGE_VERTEX_INPUT_BIT" comment="Vertex/index fetch"/>
- <enum bitpos="3" name="VK_PIPELINE_STAGE_VERTEX_SHADER_BIT" comment="Vertex shading"/>
- <enum bitpos="4" name="VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT" comment="Tessellation control shading"/>
- <enum bitpos="5" name="VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" comment="Tessellation evaluation shading"/>
- <enum bitpos="6" name="VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" comment="Geometry shading"/>
- <enum bitpos="7" name="VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT" comment="Fragment shading"/>
- <enum bitpos="8" name="VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT" comment="Early fragment (depth and stencil) tests"/>
- <enum bitpos="9" name="VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT" comment="Late fragment (depth and stencil) tests"/>
- <enum bitpos="10" name="VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT" comment="Color attachment writes"/>
- <enum bitpos="11" name="VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT" comment="Compute shading"/>
- <enum bitpos="12" name="VK_PIPELINE_STAGE_TRANSFER_BIT" comment="Transfer/copy operations"/>
- <enum bitpos="13" name="VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT" comment="After previous commands have completed"/>
- <enum bitpos="14" name="VK_PIPELINE_STAGE_HOST_BIT" comment="Indicates host (CPU) is a source/sink of the dependency"/>
- <enum bitpos="15" name="VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT" comment="All stages of the graphics pipeline"/>
- <enum bitpos="16" name="VK_PIPELINE_STAGE_ALL_COMMANDS_BIT" comment="All stages supported on the queue"/>
- </enums>
- <enums name="VkCommandPoolCreateFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_COMMAND_POOL_CREATE_TRANSIENT_BIT" comment="Command buffers have a short lifetime"/>
- <enum bitpos="1" name="VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT" comment="Command buffers may release their memory individually"/>
- </enums>
- <enums name="VkCommandPoolResetFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT" comment="Release resources owned by the pool"/>
- </enums>
- <enums name="VkCommandBufferResetFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT" comment="Release resources owned by the buffer"/>
- </enums>
- <enums name="VkSampleCountFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_SAMPLE_COUNT_1_BIT" comment="Sample count 1 supported"/>
- <enum bitpos="1" name="VK_SAMPLE_COUNT_2_BIT" comment="Sample count 2 supported"/>
- <enum bitpos="2" name="VK_SAMPLE_COUNT_4_BIT" comment="Sample count 4 supported"/>
- <enum bitpos="3" name="VK_SAMPLE_COUNT_8_BIT" comment="Sample count 8 supported"/>
- <enum bitpos="4" name="VK_SAMPLE_COUNT_16_BIT" comment="Sample count 16 supported"/>
- <enum bitpos="5" name="VK_SAMPLE_COUNT_32_BIT" comment="Sample count 32 supported"/>
- <enum bitpos="6" name="VK_SAMPLE_COUNT_64_BIT" comment="Sample count 64 supported"/>
- </enums>
- <enums name="VkAttachmentDescriptionFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT" comment="The attachment may alias physical memory of another attachment in the same render pass"/>
- </enums>
- <enums name="VkStencilFaceFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_STENCIL_FACE_FRONT_BIT" comment="Front face"/>
- <enum bitpos="1" name="VK_STENCIL_FACE_BACK_BIT" comment="Back face"/>
- <enum value="0x00000003" name="VK_STENCIL_FACE_FRONT_AND_BACK" comment="Front and back faces"/>
- <enum name="VK_STENCIL_FRONT_AND_BACK" alias="VK_STENCIL_FACE_FRONT_AND_BACK" comment="Alias for backwards compatibility"/>
- </enums>
- <enums name="VkDescriptorPoolCreateFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT" comment="Descriptor sets may be freed individually"/>
- </enums>
- <enums name="VkDependencyFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_DEPENDENCY_BY_REGION_BIT" comment="Dependency is per pixel region "/>
- </enums>
- <enums name="VkSemaphoreType" type="enum">
- <enum value="0" name="VK_SEMAPHORE_TYPE_BINARY"/>
- <enum value="1" name="VK_SEMAPHORE_TYPE_TIMELINE"/>
- </enums>
- <enums name="VkSemaphoreWaitFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_SEMAPHORE_WAIT_ANY_BIT"/>
- </enums>
-
- <comment>WSI Extensions</comment>
- <enums name="VkPresentModeKHR" type="enum">
- <enum value="0" name="VK_PRESENT_MODE_IMMEDIATE_KHR"/>
- <enum value="1" name="VK_PRESENT_MODE_MAILBOX_KHR"/>
- <enum value="2" name="VK_PRESENT_MODE_FIFO_KHR"/>
- <enum value="3" name="VK_PRESENT_MODE_FIFO_RELAXED_KHR"/>
- </enums>
- <enums name="VkColorSpaceKHR" type="enum">
- <enum value="0" name="VK_COLOR_SPACE_SRGB_NONLINEAR_KHR"/>
- <enum name="VK_COLORSPACE_SRGB_NONLINEAR_KHR" alias="VK_COLOR_SPACE_SRGB_NONLINEAR_KHR" comment="Backwards-compatible alias containing a typo"/>
- </enums>
- <enums name="VkDisplayPlaneAlphaFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"/>
- <enum bitpos="1" name="VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"/>
- <enum bitpos="2" name="VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"/>
- <enum bitpos="3" name="VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"/>
- </enums>
- <enums name="VkCompositeAlphaFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"/>
- <enum bitpos="1" name="VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"/>
- <enum bitpos="2" name="VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"/>
- <enum bitpos="3" name="VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"/>
- </enums>
- <enums name="VkSurfaceTransformFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"/>
- <enum bitpos="1" name="VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"/>
- <enum bitpos="2" name="VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"/>
- <enum bitpos="3" name="VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"/>
- <enum bitpos="4" name="VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"/>
- <enum bitpos="5" name="VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"/>
- <enum bitpos="6" name="VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"/>
- <enum bitpos="7" name="VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"/>
- <enum bitpos="8" name="VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"/>
- </enums>
- <enums name="VkTimeDomainEXT" type="enum">
- <enum value="0" name="VK_TIME_DOMAIN_DEVICE_EXT"/>
- <enum value="1" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"/>
- <enum value="2" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"/>
- <enum value="3" name="VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"/>
- </enums>
- <enums name="VkDebugReportFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_DEBUG_REPORT_INFORMATION_BIT_EXT"/>
- <enum bitpos="1" name="VK_DEBUG_REPORT_WARNING_BIT_EXT"/>
- <enum bitpos="2" name="VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT"/>
- <enum bitpos="3" name="VK_DEBUG_REPORT_ERROR_BIT_EXT"/>
- <enum bitpos="4" name="VK_DEBUG_REPORT_DEBUG_BIT_EXT"/>
- </enums>
- <enums name="VkDebugReportObjectTypeEXT" type="enum">
- <enum value="0" name="VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT"/>
- <enum value="1" name="VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT"/>
- <enum value="2" name="VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT"/>
- <enum value="3" name="VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT"/>
- <enum value="4" name="VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT"/>
- <enum value="5" name="VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT"/>
- <enum value="6" name="VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT"/>
- <enum value="7" name="VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT"/>
- <enum value="8" name="VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT"/>
- <enum value="9" name="VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT"/>
- <enum value="10" name="VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT"/>
- <enum value="11" name="VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT"/>
- <enum value="12" name="VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT"/>
- <enum value="13" name="VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT"/>
- <enum value="14" name="VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT"/>
- <enum value="15" name="VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT"/>
- <enum value="16" name="VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT"/>
- <enum value="17" name="VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT"/>
- <enum value="18" name="VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT"/>
- <enum value="19" name="VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT"/>
- <enum value="20" name="VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT"/>
- <enum value="21" name="VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT"/>
- <enum value="22" name="VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT"/>
- <enum value="23" name="VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT"/>
- <enum value="24" name="VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT"/>
- <enum value="25" name="VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT"/>
- <enum value="26" name="VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT"/>
- <enum value="27" name="VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT"/>
- <enum value="28" name="VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT"/>
- <enum name="VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT" alias="VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT" comment="Backwards-compatible alias containing a typo"/>
- <enum value="29" name="VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT"/>
- <enum value="30" name="VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT"/>
- <!--<enum value="31" name="VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT" comment="Removed NVX_device_generated_commands"/>-->
- <!--<enum value="32" name="VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT" comment="Removed NVX_device_generated_commands"/>-->
- <enum value="33" name="VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT"/>
- <enum name="VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT" alias="VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT" comment="Backwards-compatible alias containing a typo"/>
- </enums>
- <enums name="VkDeviceMemoryReportEventTypeEXT" type="enum">
- <enum value="0" name="VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT"/>
- <enum value="1" name="VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT"/>
- <enum value="2" name="VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT"/>
- <enum value="3" name="VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT"/>
- <enum value="4" name="VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT"/>
- </enums>
- <enums name="VkRasterizationOrderAMD" type="enum">
- <enum value="0" name="VK_RASTERIZATION_ORDER_STRICT_AMD"/>
- <enum value="1" name="VK_RASTERIZATION_ORDER_RELAXED_AMD"/>
- </enums>
- <enums name="VkExternalMemoryHandleTypeFlagBitsNV" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV"/>
- <enum bitpos="1" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV"/>
- <enum bitpos="2" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV"/>
- <enum bitpos="3" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV"/>
- </enums>
- <enums name="VkExternalMemoryFeatureFlagBitsNV" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV"/>
- <enum bitpos="1" name="VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV"/>
- <enum bitpos="2" name="VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV"/>
- </enums>
- <enums name="VkValidationCheckEXT" type="enum">
- <enum value="0" name="VK_VALIDATION_CHECK_ALL_EXT"/>
- <enum value="1" name="VK_VALIDATION_CHECK_SHADERS_EXT"/>
- </enums>
- <enums name="VkValidationFeatureEnableEXT" type="enum">
- <enum value="0" name="VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT"/>
- <enum value="1" name="VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT"/>
- <enum value="2" name="VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT"/>
- <enum value="3" name="VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT"/>
- <enum value="4" name="VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT"/>
- </enums>
- <enums name="VkValidationFeatureDisableEXT" type="enum">
- <enum value="0" name="VK_VALIDATION_FEATURE_DISABLE_ALL_EXT"/>
- <enum value="1" name="VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT"/>
- <enum value="2" name="VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT"/>
- <enum value="3" name="VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT"/>
- <enum value="4" name="VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT"/>
- <enum value="5" name="VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT"/>
- <enum value="6" name="VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT"/>
- <enum value="7" name="VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT"/>
- </enums>
- <enums name="VkSubgroupFeatureFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_SUBGROUP_FEATURE_BASIC_BIT" comment="Basic subgroup operations"/>
- <enum bitpos="1" name="VK_SUBGROUP_FEATURE_VOTE_BIT" comment="Vote subgroup operations"/>
- <enum bitpos="2" name="VK_SUBGROUP_FEATURE_ARITHMETIC_BIT" comment="Arithmetic subgroup operations"/>
- <enum bitpos="3" name="VK_SUBGROUP_FEATURE_BALLOT_BIT" comment="Ballot subgroup operations"/>
- <enum bitpos="4" name="VK_SUBGROUP_FEATURE_SHUFFLE_BIT" comment="Shuffle subgroup operations"/>
- <enum bitpos="5" name="VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT" comment="Shuffle relative subgroup operations"/>
- <enum bitpos="6" name="VK_SUBGROUP_FEATURE_CLUSTERED_BIT" comment="Clustered subgroup operations"/>
- <enum bitpos="7" name="VK_SUBGROUP_FEATURE_QUAD_BIT" comment="Quad subgroup operations"/>
- </enums>
- <enums name="VkIndirectCommandsLayoutUsageFlagBitsNV" type="bitmask">
- <enum bitpos="0" name="VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV"/>
- <enum bitpos="1" name="VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV"/>
- <enum bitpos="2" name="VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV"/>
- </enums>
- <enums name="VkIndirectStateFlagBitsNV" type="bitmask">
- <enum bitpos="0" name="VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV"/>
- </enums>
- <enums name="VkIndirectCommandsTokenTypeNV" type="enum">
- <enum value="0" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV"/>
- <enum value="1" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV"/>
- <enum value="2" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV"/>
- <enum value="3" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV"/>
- <enum value="4" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV"/>
- <enum value="5" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV"/>
- <enum value="6" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV"/>
- <enum value="7" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV"/>
- </enums>
- <enums name="VkPrivateDataSlotCreateFlagBitsEXT" type="bitmask">
- </enums>
- <enums name="VkDescriptorSetLayoutCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkExternalMemoryHandleTypeFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"/>
- <enum bitpos="1" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"/>
- <enum bitpos="2" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"/>
- <enum bitpos="3" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"/>
- <enum bitpos="4" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"/>
- <enum bitpos="5" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"/>
- <enum bitpos="6" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"/>
- </enums>
- <enums name="VkExternalMemoryFeatureFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"/>
- <enum bitpos="1" name="VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"/>
- <enum bitpos="2" name="VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"/>
- </enums>
- <enums name="VkExternalSemaphoreHandleTypeFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"/>
- <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"/>
- <enum bitpos="2" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"/>
- <enum bitpos="3" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"/>
- <enum name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT" alias="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"/>
- <enum bitpos="4" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"/>
- </enums>
- <enums name="VkExternalSemaphoreFeatureFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"/>
- <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"/>
- </enums>
- <enums name="VkSemaphoreImportFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"/>
- </enums>
- <enums name="VkExternalFenceHandleTypeFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"/>
- <enum bitpos="1" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"/>
- <enum bitpos="2" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"/>
- <enum bitpos="3" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"/>
- </enums>
- <enums name="VkExternalFenceFeatureFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"/>
- <enum bitpos="1" name="VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"/>
- </enums>
- <enums name="VkFenceImportFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_FENCE_IMPORT_TEMPORARY_BIT"/>
- </enums>
- <enums name="VkSurfaceCounterFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_SURFACE_COUNTER_VBLANK_BIT_EXT"/>
- <enum name="VK_SURFACE_COUNTER_VBLANK_EXT" alias="VK_SURFACE_COUNTER_VBLANK_BIT_EXT" comment="Backwards-compatible alias containing a typo"/>
- </enums>
- <enums name="VkDisplayPowerStateEXT" type="enum">
- <enum value="0" name="VK_DISPLAY_POWER_STATE_OFF_EXT"/>
- <enum value="1" name="VK_DISPLAY_POWER_STATE_SUSPEND_EXT"/>
- <enum value="2" name="VK_DISPLAY_POWER_STATE_ON_EXT"/>
- </enums>
- <enums name="VkDeviceEventTypeEXT" type="enum">
- <enum value="0" name="VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT"/>
- </enums>
- <enums name="VkDisplayEventTypeEXT" type="enum">
- <enum value="0" name="VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT"/>
- </enums>
- <enums name="VkPeerMemoryFeatureFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT" comment="Can read with vkCmdCopy commands"/>
- <enum bitpos="1" name="VK_PEER_MEMORY_FEATURE_COPY_DST_BIT" comment="Can write with vkCmdCopy commands"/>
- <enum bitpos="2" name="VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT" comment="Can read with any access type/command"/>
- <enum bitpos="3" name="VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT" comment="Can write with and access type/command"/>
- </enums>
- <enums name="VkMemoryAllocateFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT" comment="Force allocation on specific devices"/>
- </enums>
- <enums name="VkDeviceGroupPresentModeFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR" comment="Present from local memory"/>
- <enum bitpos="1" name="VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR" comment="Present from remote memory"/>
- <enum bitpos="2" name="VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR" comment="Present sum of local and/or remote memory"/>
- <enum bitpos="3" name="VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR" comment="Each physical device presents from local memory"/>
- </enums>
- <enums name="VkSwapchainCreateFlagBitsKHR" type="bitmask">
- </enums>
- <enums name="VkViewportCoordinateSwizzleNV" type="enum">
- <enum value="0" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV"/>
- <enum value="1" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV"/>
- <enum value="2" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV"/>
- <enum value="3" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV"/>
- <enum value="4" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV"/>
- <enum value="5" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV"/>
- <enum value="6" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV"/>
- <enum value="7" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV"/>
- </enums>
- <enums name="VkDiscardRectangleModeEXT" type="enum">
- <enum value="0" name="VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT"/>
- <enum value="1" name="VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT"/>
- </enums>
- <enums name="VkSubpassDescriptionFlagBits" type="bitmask">
- </enums>
- <enums name="VkPointClippingBehavior" type="enum">
- <enum value="0" name="VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"/>
- <enum value="1" name="VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"/>
- </enums>
- <enums name="VkSamplerReductionMode" type="enum">
- <enum value="0" name="VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE"/>
- <enum value="1" name="VK_SAMPLER_REDUCTION_MODE_MIN"/>
- <enum value="2" name="VK_SAMPLER_REDUCTION_MODE_MAX"/>
- </enums>
- <enums name="VkTessellationDomainOrigin" type="enum">
- <enum value="0" name="VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT"/>
- <enum value="1" name="VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT"/>
- </enums>
- <enums name="VkSamplerYcbcrModelConversion" type="enum">
- <enum value="0" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY"/>
- <enum value="1" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY" comment="just range expansion"/>
- <enum value="2" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709" comment="aka HD YUV"/>
- <enum value="3" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601" comment="aka SD YUV"/>
- <enum value="4" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020" comment="aka UHD YUV"/>
- </enums>
- <enums name="VkSamplerYcbcrRange" type="enum">
- <enum value="0" name="VK_SAMPLER_YCBCR_RANGE_ITU_FULL" comment="Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)"/>
- <enum value="1" name="VK_SAMPLER_YCBCR_RANGE_ITU_NARROW" comment="Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240"/>
- </enums>
- <enums name="VkChromaLocation" type="enum">
- <enum value="0" name="VK_CHROMA_LOCATION_COSITED_EVEN"/>
- <enum value="1" name="VK_CHROMA_LOCATION_MIDPOINT"/>
- </enums>
- <enums name="VkBlendOverlapEXT" type="enum">
- <enum value="0" name="VK_BLEND_OVERLAP_UNCORRELATED_EXT"/>
- <enum value="1" name="VK_BLEND_OVERLAP_DISJOINT_EXT"/>
- <enum value="2" name="VK_BLEND_OVERLAP_CONJOINT_EXT"/>
- </enums>
- <enums name="VkCoverageModulationModeNV" type="enum">
- <enum value="0" name="VK_COVERAGE_MODULATION_MODE_NONE_NV"/>
- <enum value="1" name="VK_COVERAGE_MODULATION_MODE_RGB_NV"/>
- <enum value="2" name="VK_COVERAGE_MODULATION_MODE_ALPHA_NV"/>
- <enum value="3" name="VK_COVERAGE_MODULATION_MODE_RGBA_NV"/>
- </enums>
- <enums name="VkCoverageReductionModeNV" type="enum">
- <enum value="0" name="VK_COVERAGE_REDUCTION_MODE_MERGE_NV"/>
- <enum value="1" name="VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV"/>
- </enums>
- <enums name="VkValidationCacheHeaderVersionEXT" type="enum">
- <enum value="1" name="VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT"/>
- </enums>
- <enums name="VkShaderInfoTypeAMD" type="enum">
- <enum value="0" name="VK_SHADER_INFO_TYPE_STATISTICS_AMD"/>
- <enum value="1" name="VK_SHADER_INFO_TYPE_BINARY_AMD"/>
- <enum value="2" name="VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD"/>
- </enums>
- <enums name="VkQueueGlobalPriorityEXT" type="enum">
- <enum value="128" name="VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT"/>
- <enum value="256" name="VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT"/>
- <enum value="512" name="VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT"/>
- <enum value="1024" name="VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT"/>
- </enums>
- <enums name="VkDebugUtilsMessageSeverityFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT"/>
- <enum bitpos="4" name="VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT"/>
- <enum bitpos="8" name="VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT"/>
- <enum bitpos="12" name="VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT"/>
- </enums>
- <enums name="VkDebugUtilsMessageTypeFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT"/>
- <enum bitpos="1" name="VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT"/>
- <enum bitpos="2" name="VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT"/>
- </enums>
- <enums name="VkConservativeRasterizationModeEXT" type="enum">
- <enum value="0" name="VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT"/>
- <enum value="1" name="VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT"/>
- <enum value="2" name="VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT"/>
- </enums>
- <enums name="VkDescriptorBindingFlagBits" type="bitmask">
- <enum bitpos="0" name="VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"/>
- <enum bitpos="1" name="VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"/>
- <enum bitpos="2" name="VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"/>
- <enum bitpos="3" name="VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"/>
- </enums>
- <enums name="VkVendorId" type="enum">
- <comment>Vendor IDs are now represented as enums instead of the old
- <vendorids> tag, allowing them to be included in the
- API headers.</comment>
- <enum value="0x10001" name="VK_VENDOR_ID_VIV" comment="Vivante vendor ID"/>
- <enum value="0x10002" name="VK_VENDOR_ID_VSI" comment="VeriSilicon vendor ID"/>
- <enum value="0x10003" name="VK_VENDOR_ID_KAZAN" comment="Kazan Software Renderer"/>
- <enum value="0x10004" name="VK_VENDOR_ID_CODEPLAY" comment="Codeplay Software Ltd. vendor ID"/>
- <enum value="0x10005" name="VK_VENDOR_ID_MESA" comment="Mesa vendor ID"/>
- <enum value="0x10006" name="VK_VENDOR_ID_POCL" comment="PoCL vendor ID"/>
- <unused start="0x10007" comment="This is the next unused available Khronos vendor ID"/>
- </enums>
- <enums name="VkDriverId" type="enum">
- <comment>Driver IDs are now represented as enums instead of the old
- <driverids> tag, allowing them to be included in the
- API headers.</comment>
- <enum value="1" name="VK_DRIVER_ID_AMD_PROPRIETARY" comment="Advanced Micro Devices, Inc."/>
- <enum value="2" name="VK_DRIVER_ID_AMD_OPEN_SOURCE" comment="Advanced Micro Devices, Inc."/>
- <enum value="3" name="VK_DRIVER_ID_MESA_RADV" comment="Mesa open source project"/>
- <enum value="4" name="VK_DRIVER_ID_NVIDIA_PROPRIETARY" comment="NVIDIA Corporation"/>
- <enum value="5" name="VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS" comment="Intel Corporation"/>
- <enum value="6" name="VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA" comment="Intel Corporation"/>
- <enum value="7" name="VK_DRIVER_ID_IMAGINATION_PROPRIETARY" comment="Imagination Technologies"/>
- <enum value="8" name="VK_DRIVER_ID_QUALCOMM_PROPRIETARY" comment="Qualcomm Technologies, Inc."/>
- <enum value="9" name="VK_DRIVER_ID_ARM_PROPRIETARY" comment="Arm Limited"/>
- <enum value="10" name="VK_DRIVER_ID_GOOGLE_SWIFTSHADER" comment="Google LLC"/>
- <enum value="11" name="VK_DRIVER_ID_GGP_PROPRIETARY" comment="Google LLC"/>
- <enum value="12" name="VK_DRIVER_ID_BROADCOM_PROPRIETARY" comment="Broadcom Inc."/>
- <enum value="13" name="VK_DRIVER_ID_MESA_LLVMPIPE" comment="Mesa"/>
- <enum value="14" name="VK_DRIVER_ID_MOLTENVK" comment="MoltenVK"/>
- <enum value="15" name="VK_DRIVER_ID_COREAVI_PROPRIETARY" comment="Core Avionics & Industrial Inc."/>
- <enum value="16" name="VK_DRIVER_ID_JUICE_PROPRIETARY" comment="Juice Technologies, Inc."/>
- <enum value="17" name="VK_DRIVER_ID_VERISILICON_PROPRIETARY" comment="Verisilicon, Inc."/>
- <enum value="18" name="VK_DRIVER_ID_MESA_TURNIP" comment="Mesa open source project"/>
- <enum value="19" name="VK_DRIVER_ID_MESA_V3DV" comment="Mesa open source project"/>
- <enum value="20" name="VK_DRIVER_ID_MESA_PANVK" comment="Mesa open source project"/>
- </enums>
- <enums name="VkConditionalRenderingFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT"/>
- </enums>
- <enums name="VkResolveModeFlagBits" type="bitmask">
- <enum value="0" name="VK_RESOLVE_MODE_NONE"/>
- <enum bitpos="0" name="VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"/>
- <enum bitpos="1" name="VK_RESOLVE_MODE_AVERAGE_BIT"/>
- <enum bitpos="2" name="VK_RESOLVE_MODE_MIN_BIT"/>
- <enum bitpos="3" name="VK_RESOLVE_MODE_MAX_BIT"/>
- </enums>
- <enums name="VkShadingRatePaletteEntryNV" type="enum">
- <enum value="0" name="VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV"/>
- <enum value="1" name="VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="2" name="VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="3" name="VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="4" name="VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="5" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV"/>
- <enum value="6" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV"/>
- <enum value="7" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV"/>
- <enum value="8" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV"/>
- <enum value="9" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV"/>
- <enum value="10" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV"/>
- <enum value="11" name="VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV"/>
- </enums>
- <enums name="VkCoarseSampleOrderTypeNV" type="enum">
- <enum value="0" name="VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV"/>
- <enum value="1" name="VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV"/>
- <enum value="2" name="VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV"/>
- <enum value="3" name="VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV"/>
- </enums>
- <enums name="VkGeometryInstanceFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR"/>
- <enum bitpos="1" name="VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR"/>
- <enum bitpos="2" name="VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR"/>
- <enum bitpos="3" name="VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR"/>
- <enum name="VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR" alias="VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR"/>
- </enums>
- <enums name="VkGeometryFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_GEOMETRY_OPAQUE_BIT_KHR"/>
- <enum bitpos="1" name="VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR"/>
- </enums>
- <enums name="VkBuildAccelerationStructureFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR"/>
- <enum bitpos="1" name="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR"/>
- <enum bitpos="2" name="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR"/>
- <enum bitpos="3" name="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR"/>
- <enum bitpos="4" name="VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR"/>
- </enums>
- <enums name="VkAccelerationStructureCreateFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR"/>
- </enums>
- <enums name="VkCopyAccelerationStructureModeKHR" type="enum">
- <enum value="0" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR"/>
- <enum value="1" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR"/>
- <enum value="2" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR"/>
- <enum value="3" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR"/>
- </enums>
- <enums name="VkBuildAccelerationStructureModeKHR" type="enum">
- <enum value="0" name="VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR"/>
- <enum value="1" name="VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR"/>
- </enums>
- <enums name="VkAccelerationStructureTypeKHR" type="enum">
- <enum value="0" name="VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR"/>
- <enum value="1" name="VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR"/>
- <enum value="2" name="VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR"/>
- </enums>
- <enums name="VkGeometryTypeKHR" type="enum">
- <enum value="0" name="VK_GEOMETRY_TYPE_TRIANGLES_KHR"/>
- <enum value="1" name="VK_GEOMETRY_TYPE_AABBS_KHR"/>
- <enum value="2" name="VK_GEOMETRY_TYPE_INSTANCES_KHR"/>
- </enums>
- <enums name="VkAccelerationStructureMemoryRequirementsTypeNV" type="enum">
- <enum value="0" name="VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV"/>
- <enum value="1" name="VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV"/>
- <enum value="2" name="VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV"/>
- </enums>
- <enums name="VkAccelerationStructureBuildTypeKHR" type="enum">
- <enum value="0" name="VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR"/>
- <enum value="1" name="VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR"/>
- <enum value="2" name="VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR"/>
- </enums>
- <enums name="VkRayTracingShaderGroupTypeKHR" type="enum">
- <enum value="0" name="VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR"/>
- <enum value="1" name="VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR"/>
- <enum value="2" name="VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR"/>
- </enums>
- <enums name="VkAccelerationStructureCompatibilityKHR" type="enum">
- <enum value="0" name="VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR"/>
- <enum value="1" name="VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR"/>
- </enums>
- <enums name="VkShaderGroupShaderKHR" type="enum">
- <enum value="0" name="VK_SHADER_GROUP_SHADER_GENERAL_KHR"/>
- <enum value="1" name="VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR"/>
- <enum value="2" name="VK_SHADER_GROUP_SHADER_ANY_HIT_KHR"/>
- <enum value="3" name="VK_SHADER_GROUP_SHADER_INTERSECTION_KHR"/>
- </enums>
- <enums name="VkMemoryOverallocationBehaviorAMD" type="enum">
- <enum value="0" name="VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD"/>
- <enum value="1" name="VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD"/>
- <enum value="2" name="VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD"/>
- </enums>
- <enums name="VkFramebufferCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkScopeNV" type="enum">
- <enum value="1" name="VK_SCOPE_DEVICE_NV"/>
- <enum value="2" name="VK_SCOPE_WORKGROUP_NV"/>
- <enum value="3" name="VK_SCOPE_SUBGROUP_NV"/>
- <enum value="5" name="VK_SCOPE_QUEUE_FAMILY_NV"/>
- </enums>
- <enums name="VkComponentTypeNV" type="enum">
- <enum value="0" name="VK_COMPONENT_TYPE_FLOAT16_NV"/>
- <enum value="1" name="VK_COMPONENT_TYPE_FLOAT32_NV"/>
- <enum value="2" name="VK_COMPONENT_TYPE_FLOAT64_NV"/>
- <enum value="3" name="VK_COMPONENT_TYPE_SINT8_NV"/>
- <enum value="4" name="VK_COMPONENT_TYPE_SINT16_NV"/>
- <enum value="5" name="VK_COMPONENT_TYPE_SINT32_NV"/>
- <enum value="6" name="VK_COMPONENT_TYPE_SINT64_NV"/>
- <enum value="7" name="VK_COMPONENT_TYPE_UINT8_NV"/>
- <enum value="8" name="VK_COMPONENT_TYPE_UINT16_NV"/>
- <enum value="9" name="VK_COMPONENT_TYPE_UINT32_NV"/>
- <enum value="10" name="VK_COMPONENT_TYPE_UINT64_NV"/>
- </enums>
- <enums name="VkDeviceDiagnosticsConfigFlagBitsNV" type="bitmask">
- <enum bitpos="0" name="VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV"/>
- <enum bitpos="1" name="VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV"/>
- <enum bitpos="2" name="VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV"/>
- </enums>
- <enums name="VkPipelineCreationFeedbackFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT"/>
- <enum bitpos="1" name="VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT"/>
- <enum bitpos="2" name="VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT"/>
- </enums>
- <enums name="VkFullScreenExclusiveEXT" type="enum">
- <enum value="0" name="VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT"/>
- <enum value="1" name="VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT"/>
- <enum value="2" name="VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT"/>
- <enum value="3" name="VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT"/>
- </enums>
- <enums name="VkPerformanceCounterScopeKHR" type="enum">
- <enum value="0" name="VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR"/>
- <enum value="1" name="VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR"/>
- <enum value="2" name="VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR"/>
- <enum name="VK_QUERY_SCOPE_COMMAND_BUFFER_KHR" alias="VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR"/>
- <enum name="VK_QUERY_SCOPE_RENDER_PASS_KHR" alias="VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR"/>
- <enum name="VK_QUERY_SCOPE_COMMAND_KHR" alias="VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR"/>
- </enums>
- <enums name="VkPerformanceCounterUnitKHR" type="enum">
- <enum value="0" name="VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR"/>
- <enum value="1" name="VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR"/>
- <enum value="2" name="VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR"/>
- <enum value="3" name="VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR"/>
- <enum value="4" name="VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR"/>
- <enum value="5" name="VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR"/>
- <enum value="6" name="VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR"/>
- <enum value="7" name="VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR"/>
- <enum value="8" name="VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR"/>
- <enum value="9" name="VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR"/>
- <enum value="10" name="VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR"/>
- </enums>
- <enums name="VkPerformanceCounterStorageKHR" type="enum">
- <enum value="0" name="VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR"/>
- <enum value="1" name="VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR"/>
- <enum value="2" name="VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR"/>
- <enum value="3" name="VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR"/>
- <enum value="4" name="VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR"/>
- <enum value="5" name="VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR"/>
- </enums>
- <enums name="VkPerformanceCounterDescriptionFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR"/>
- <enum name="VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR" alias="VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR" comment="Backwards-compatible alias containing a typo"/>
- <enum bitpos="1" name="VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR"/>
- <enum name="VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR" alias="VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR" comment="Backwards-compatible alias containing a typo"/>
- </enums>
- <enums name="VkAcquireProfilingLockFlagBitsKHR" type="bitmask">
- </enums>
- <enums name="VkShaderCorePropertiesFlagBitsAMD" type="bitmask">
- </enums>
- <enums name="VkPerformanceConfigurationTypeINTEL" type="enum">
- <enum value="0" name="VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL"/>
- </enums>
- <enums name="VkQueryPoolSamplingModeINTEL" type="enum">
- <enum value="0" name="VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL"/>
- </enums>
- <enums name="VkPerformanceOverrideTypeINTEL" type="enum">
- <enum value="0" name="VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL"/>
- <enum value="1" name="VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL"/>
- </enums>
- <enums name="VkPerformanceParameterTypeINTEL" type="enum">
- <enum value="0" name="VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL"/>
- <enum value="1" name="VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL"/>
- </enums>
- <enums name="VkPerformanceValueTypeINTEL" type="enum">
- <enum value="0" name="VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL"/>
- <enum value="1" name="VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL"/>
- <enum value="2" name="VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL"/>
- <enum value="3" name="VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL"/>
- <enum value="4" name="VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL"/>
- </enums>
- <enums name="VkShaderFloatControlsIndependence" type="enum">
- <enum value="0" name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"/>
- <enum value="1" name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"/>
- <enum value="2" name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"/>
- </enums>
- <enums name="VkPipelineExecutableStatisticFormatKHR" type="enum">
- <enum value="0" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR"/>
- <enum value="1" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR"/>
- <enum value="2" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR"/>
- <enum value="3" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR"/>
- </enums>
- <enums name="VkLineRasterizationModeEXT" type="enum">
- <enum value="0" name="VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"/>
- <enum value="1" name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"/>
- <enum value="2" name="VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"/>
- <enum value="3" name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"/>
- </enums>
- <enums name="VkShaderModuleCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkPipelineCompilerControlFlagBitsAMD" type="bitmask">
- </enums>
- <enums name="VkToolPurposeFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_TOOL_PURPOSE_VALIDATION_BIT_EXT"/>
- <enum bitpos="1" name="VK_TOOL_PURPOSE_PROFILING_BIT_EXT"/>
- <enum bitpos="2" name="VK_TOOL_PURPOSE_TRACING_BIT_EXT"/>
- <enum bitpos="3" name="VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT"/>
- <enum bitpos="4" name="VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT"/>
- </enums>
- <enums name="VkFragmentShadingRateCombinerOpKHR" type="enum">
- <enum value="0" name="VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR"/>
- <enum value="1" name="VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR"/>
- <enum value="2" name="VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR"/>
- <enum value="3" name="VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR"/>
- <enum value="4" name="VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR"/>
- </enums>
- <enums name="VkFragmentShadingRateNV" type="enum">
- <enum value="0" name="VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV"/>
- <enum value="1" name="VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV"/>
- <enum value="4" name="VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV"/>
- <enum value="5" name="VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV"/>
- <enum value="6" name="VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV"/>
- <enum value="9" name="VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV"/>
- <enum value="10" name="VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV"/>
- <enum value="11" name="VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="12" name="VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="13" name="VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="14" name="VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV"/>
- <enum value="15" name="VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV"/>
- </enums>
- <enums name="VkFragmentShadingRateTypeNV" type="enum">
- <enum value="0" name="VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV"/>
- <enum value="1" name="VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV"/>
- </enums>
- <enums name="VkAccessFlagBits2KHR" type="bitmask" bitwidth="64">
- <enum value="0" name="VK_ACCESS_2_NONE_KHR"/>
- <enum bitpos="0" name="VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR"/>
- <enum bitpos="1" name="VK_ACCESS_2_INDEX_READ_BIT_KHR"/>
- <enum bitpos="2" name="VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR"/>
- <enum bitpos="3" name="VK_ACCESS_2_UNIFORM_READ_BIT_KHR"/>
- <enum bitpos="4" name="VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR"/>
- <enum bitpos="5" name="VK_ACCESS_2_SHADER_READ_BIT_KHR"/>
- <enum bitpos="6" name="VK_ACCESS_2_SHADER_WRITE_BIT_KHR"/>
- <enum bitpos="7" name="VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR"/>
- <enum bitpos="8" name="VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR"/>
- <enum bitpos="9" name="VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR"/>
- <enum bitpos="10" name="VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR"/>
- <enum bitpos="11" name="VK_ACCESS_2_TRANSFER_READ_BIT_KHR"/>
- <enum bitpos="12" name="VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR"/>
- <enum bitpos="13" name="VK_ACCESS_2_HOST_READ_BIT_KHR"/>
- <enum bitpos="14" name="VK_ACCESS_2_HOST_WRITE_BIT_KHR"/>
- <enum bitpos="15" name="VK_ACCESS_2_MEMORY_READ_BIT_KHR"/>
- <enum bitpos="16" name="VK_ACCESS_2_MEMORY_WRITE_BIT_KHR"/>
- <!-- bitpos 17-31 are specified by extensions to the original VkAccessFlagBits enum -->
- <enum bitpos="32" name="VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR"/>
- <enum bitpos="33" name="VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR"/>
- <enum bitpos="34" name="VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR"/>
- </enums>
- <enums name="VkPipelineStageFlagBits2KHR" type="bitmask" bitwidth="64">
- <enum value="0" name="VK_PIPELINE_STAGE_2_NONE_KHR"/>
- <enum bitpos="0" name="VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR"/>
- <enum bitpos="1" name="VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR"/>
- <enum bitpos="2" name="VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR"/>
- <enum bitpos="3" name="VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR"/>
- <enum bitpos="4" name="VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR"/>
- <enum bitpos="5" name="VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR"/>
- <enum bitpos="6" name="VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR"/>
- <enum bitpos="7" name="VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR"/>
- <enum bitpos="8" name="VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR"/>
- <enum bitpos="9" name="VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR"/>
- <enum bitpos="10" name="VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR"/>
- <enum bitpos="11" name="VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR"/>
- <enum bitpos="12" name="VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"/>
- <enum name="VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR" alias="VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"/>
- <enum bitpos="13" name="VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR"/>
- <enum bitpos="14" name="VK_PIPELINE_STAGE_2_HOST_BIT_KHR"/>
- <enum bitpos="15" name="VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR"/>
- <enum bitpos="16" name="VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR"/>
- <!-- bitpos 17-31 are specified by extensions to the original VkPipelineStageFlagBits enum -->
- <enum bitpos="32" name="VK_PIPELINE_STAGE_2_COPY_BIT_KHR"/>
- <enum bitpos="33" name="VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR"/>
- <enum bitpos="34" name="VK_PIPELINE_STAGE_2_BLIT_BIT_KHR"/>
- <enum bitpos="35" name="VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR"/>
- <enum bitpos="36" name="VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR"/>
- <enum bitpos="37" name="VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR"/>
- <enum bitpos="38" name="VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR"/>
- </enums>
- <enums name="VkSubmitFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_SUBMIT_PROTECTED_BIT_KHR"/>
- </enums>
- <enums name="VkEventCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkPipelineLayoutCreateFlagBits" type="bitmask">
- </enums>
- <enums name="VkProvokingVertexModeEXT" type="enum">
- <enum value="0" name="VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT"/>
- <enum value="1" name="VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT"/>
- </enums>
- <enums name="VkAccelerationStructureMotionInstanceTypeNV" type="enum">
- <enum value="0" name="VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV"/>
- <enum value="1" name="VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV"/>
- <enum value="2" name="VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV"/>
- </enums>
-
- <enums name="VkVideoCodecOperationFlagBitsKHR" type="bitmask">
- <enum value="0" name="VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR"/>
- </enums>
- <enums name="VkVideoChromaSubsamplingFlagBitsKHR" type="bitmask" comment="Vulkan video chroma subsampling definitions">
- <enum value="0" name="VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR"/>
- <enum bitpos="0" name="VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR"/>
- <enum bitpos="1" name="VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR"/>
- <enum bitpos="2" name="VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR"/>
- <enum bitpos="3" name="VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR"/>
- </enums>
- <enums name="VkVideoComponentBitDepthFlagBitsKHR" type="bitmask" comment="Vulkan video component bit depth definitions">
- <enum value="0" name="VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR"/>
- <enum bitpos="0" name="VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR"/>
- <enum bitpos="2" name="VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR"/>
- <enum bitpos="4" name="VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR"/>
- </enums>
- <enums name="VkVideoCapabilityFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR"/>
- <enum bitpos="1" name="VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR"/>
- </enums>
- <enums name="VkVideoSessionCreateFlagBitsKHR" type="bitmask">
- <enum value="0" name="VK_VIDEO_SESSION_CREATE_DEFAULT_KHR"/>
- <enum bitpos="0" name="VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR"/>
- </enums>
- <enums name="VkVideoCodingQualityPresetFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR"/>
- <enum bitpos="1" name="VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR"/>
- <enum bitpos="2" name="VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR"/>
- </enums>
- <enums name="VkVideoDecodeH264PictureLayoutFlagBitsEXT" type="bitmask">
- <enum value="0" name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT"/>
- <enum bitpos="0" name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT"/>
- </enums>
- <enums name="VkVideoCodingControlFlagBitsKHR" type="bitmask">
- <enum value="0" name="VK_VIDEO_CODING_CONTROL_DEFAULT_KHR"/>
- <enum bitpos="0" name="VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR"/>
- </enums>
- <enums name="VkQueryResultStatusKHR" type="enum">
- <enum value="-1" name="VK_QUERY_RESULT_STATUS_ERROR_KHR"/>
- <enum value="0" name="VK_QUERY_RESULT_STATUS_NOT_READY_KHR"/>
- <enum value="1" name="VK_QUERY_RESULT_STATUS_COMPLETE_KHR"/>
- </enums>
- <enums name="VkVideoDecodeFlagBitsKHR" type="bitmask">
- <enum value="0" name="VK_VIDEO_DECODE_DEFAULT_KHR"/>
- <enum bitpos="0" name="VK_VIDEO_DECODE_RESERVED_0_BIT_KHR"/>
- </enums>
- <enums name="VkVideoEncodeFlagBitsKHR" type="bitmask">
- <enum value="0" name="VK_VIDEO_ENCODE_DEFAULT_KHR"/>
- <enum bitpos="0" name="VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR"/>
- </enums>
- <enums name="VkVideoEncodeRateControlFlagBitsKHR" type="bitmask">
- <enum value="0" name="VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR"/>
- <enum bitpos="0" name="VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR"/>
- </enums>
- <enums name="VkVideoEncodeRateControlModeFlagBitsKHR" type="bitmask">
- <enum value="0" name="VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR"/>
- <enum value="1" name="VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR"/>
- <enum value="2" name="VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR"/>
- </enums>
- <enums name="VkVideoEncodeH264CapabilityFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT"/>
- <enum bitpos="2" name="VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT"/>
- <enum bitpos="3" name="VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT"/>
- <enum bitpos="4" name="VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT"/>
- <enum bitpos="5" name="VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT"/>
- <enum bitpos="6" name="VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT"/>
- <enum bitpos="7" name="VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT"/>
- <enum bitpos="8" name="VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT"/>
- <enum bitpos="9" name="VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT"/>
- <enum bitpos="10" name="VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT"/>
- </enums>
- <enums name="VkVideoEncodeH264InputModeFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT"/>
- <enum bitpos="2" name="VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT"/>
- </enums>
- <enums name="VkVideoEncodeH264OutputModeFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT"/>
- <enum bitpos="2" name="VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT"/>
- </enums>
- <enums name="VkVideoEncodeH264CreateFlagBitsEXT" type="bitmask">
- <enum value="0" name="VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT"/>
- <enum bitpos="0" name="VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT"/>
- </enums>
- <enums name="VkImageFormatConstraintsFlagBitsFUCHSIA" type="bitmask">
- </enums>
- <enums name="VkImageConstraintsInfoFlagBitsFUCHSIA" type="bitmask">
- <enum bitpos="0" name="VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA"/>
- <enum bitpos="1" name="VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA"/>
- <enum bitpos="2" name="VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA"/>
- <enum bitpos="3" name="VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA"/>
- <enum bitpos="4" name="VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA"/>
- </enums>
- <enums name="VkFormatFeatureFlagBits2KHR" type="bitmask" bitwidth="64">
- <enum bitpos="0" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR"/>
- <enum bitpos="1" name="VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR"/>
- <enum bitpos="2" name="VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR"/>
- <enum bitpos="3" name="VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"/>
- <enum bitpos="4" name="VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"/>
- <enum bitpos="5" name="VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR"/>
- <enum bitpos="6" name="VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR"/>
- <enum bitpos="7" name="VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR"/>
- <enum bitpos="8" name="VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR"/>
- <enum bitpos="9" name="VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR"/>
- <enum bitpos="10" name="VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR"/>
- <enum bitpos="11" name="VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR"/>
- <enum bitpos="12" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR"/>
- <enum bitpos="13" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"/>
- <enum bitpos="14" name="VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR"/>
- <enum bitpos="15" name="VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR"/>
- <enum bitpos="16" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR"/>
- <enum bitpos="17" name="VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR"/>
- <enum bitpos="18" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR"/>
- <enum bitpos="19" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR"/>
- <enum bitpos="20" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR"/>
- <enum bitpos="21" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR"/>
- <enum bitpos="22" name="VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR"/>
- <enum bitpos="23" name="VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR"/>
- <enum bitpos="31" name="VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR"/>
- <enum bitpos="32" name="VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR"/>
- <enum bitpos="33" name="VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR"/>
- </enums>
- <enums name="VkVideoEncodeH265InputModeFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_BIT_EXT"/>
- <enum bitpos="2" name="VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT"/>
- </enums>
- <enums name="VkVideoEncodeH265OutputModeFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_BIT_EXT"/>
- <enum bitpos="2" name="VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT"/>
- </enums>
- <enums name="VkVideoEncodeH265CtbSizeFlagBitsEXT" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_ENCODE_H265_CTB_SIZE_8_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT"/>
- <enum bitpos="2" name="VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT"/>
- <enum bitpos="3" name="VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT"/>
- </enums>
- <enums name="VkRenderingFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR"/>
- <enum bitpos="1" name="VK_RENDERING_SUSPENDING_BIT_KHR"/>
- <enum bitpos="2" name="VK_RENDERING_RESUMING_BIT_KHR"/>
- </enums>
-
- <commands comment="Vulkan command definitions">
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_LAYER_NOT_PRESENT,VK_ERROR_EXTENSION_NOT_PRESENT,VK_ERROR_INCOMPATIBLE_DRIVER">
- <proto><type>VkResult</type> <name>vkCreateInstance</name></proto>
- <param>const <type>VkInstanceCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkInstance</type>* <name>pInstance</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyInstance</name></proto>
- <param optional="true" externsync="true"><type>VkInstance</type> <name>instance</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <implicitexternsyncparams>
- <param>all sname:VkPhysicalDevice objects enumerated from pname:instance</param>
- </implicitexternsyncparams>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkEnumeratePhysicalDevices</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPhysicalDeviceCount</name></param>
- <param optional="true" len="pPhysicalDeviceCount"><type>VkPhysicalDevice</type>* <name>pPhysicalDevices</name></param>
- </command>
- <command>
- <proto><type>PFN_vkVoidFunction</type> <name>vkGetDeviceProcAddr</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param len="null-terminated">const <type>char</type>* <name>pName</name></param>
- </command>
- <command>
- <proto><type>PFN_vkVoidFunction</type> <name>vkGetInstanceProcAddr</name></proto>
- <param optional="true"><type>VkInstance</type> <name>instance</name></param>
- <param len="null-terminated">const <type>char</type>* <name>pName</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkPhysicalDeviceProperties</type>* <name>pProperties</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceQueueFamilyProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pQueueFamilyPropertyCount</name></param>
- <param optional="true" len="pQueueFamilyPropertyCount"><type>VkQueueFamilyProperties</type>* <name>pQueueFamilyProperties</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceMemoryProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkPhysicalDeviceMemoryProperties</type>* <name>pMemoryProperties</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceFeatures</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkPhysicalDeviceFeatures</type>* <name>pFeatures</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceFormatProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkFormat</type> <name>format</name></param>
- <param><type>VkFormatProperties</type>* <name>pFormatProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FORMAT_NOT_SUPPORTED">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceImageFormatProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkFormat</type> <name>format</name></param>
- <param><type>VkImageType</type> <name>type</name></param>
- <param><type>VkImageTiling</type> <name>tiling</name></param>
- <param><type>VkImageUsageFlags</type> <name>usage</name></param>
- <param optional="true"><type>VkImageCreateFlags</type> <name>flags</name></param>
- <param><type>VkImageFormatProperties</type>* <name>pImageFormatProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_EXTENSION_NOT_PRESENT,VK_ERROR_FEATURE_NOT_PRESENT,VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkCreateDevice</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkDeviceCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDevice</type>* <name>pDevice</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyDevice</name></proto>
- <param optional="true" externsync="true"><type>VkDevice</type> <name>device</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <implicitexternsyncparams>
- <param>all sname:VkQueue objects created from pname:device</param>
- </implicitexternsyncparams>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkEnumerateInstanceVersion</name></proto>
- <param><type>uint32_t</type>* <name>pApiVersion</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkEnumerateInstanceLayerProperties</name></proto>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkLayerProperties</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_LAYER_NOT_PRESENT">
- <proto><type>VkResult</type> <name>vkEnumerateInstanceExtensionProperties</name></proto>
- <param optional="true" len="null-terminated">const <type>char</type>* <name>pLayerName</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkExtensionProperties</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkEnumerateDeviceLayerProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkLayerProperties</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_LAYER_NOT_PRESENT">
- <proto><type>VkResult</type> <name>vkEnumerateDeviceExtensionProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="true" len="null-terminated">const <type>char</type>* <name>pLayerName</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkExtensionProperties</type>* <name>pProperties</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetDeviceQueue</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param><type>uint32_t</type> <name>queueIndex</name></param>
- <param><type>VkQueue</type>* <name>pQueue</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkQueueSubmit</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param optional="true"><type>uint32_t</type> <name>submitCount</name></param>
- <param len="submitCount">const <type>VkSubmitInfo</type>* <name>pSubmits</name></param>
- <param optional="true" externsync="true"><type>VkFence</type> <name>fence</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkQueueWaitIdle</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkDeviceWaitIdle</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <implicitexternsyncparams>
- <param>all sname:VkQueue objects created from pname:device</param>
- </implicitexternsyncparams>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE,VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR">
- <proto><type>VkResult</type> <name>vkAllocateMemory</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkMemoryAllocateInfo</type>* <name>pAllocateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDeviceMemory</type>* <name>pMemory</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkFreeMemory</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_MEMORY_MAP_FAILED">
- <proto><type>VkResult</type> <name>vkMapMemory</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>VkDeviceSize</type> <name>size</name></param>
- <param optional="true"><type>VkMemoryMapFlags</type> <name>flags</name></param>
- <param optional="false,true"><type>void</type>** <name>ppData</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkUnmapMemory</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkFlushMappedMemoryRanges</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>memoryRangeCount</name></param>
- <param len="memoryRangeCount">const <type>VkMappedMemoryRange</type>* <name>pMemoryRanges</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkInvalidateMappedMemoryRanges</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>memoryRangeCount</name></param>
- <param len="memoryRangeCount">const <type>VkMappedMemoryRange</type>* <name>pMemoryRanges</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetDeviceMemoryCommitment</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param devicememoryoffset="1"><type>VkDeviceSize</type>* <name>pCommittedMemoryInBytes</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetBufferMemoryRequirements</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkMemoryRequirements</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR">
- <proto><type>VkResult</type> <name>vkBindBufferMemory</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkBuffer</type> <name>buffer</name></param>
- <param devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param devicememoryoffset="1"><type>VkDeviceSize</type> <name>memoryOffset</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetImageMemoryRequirements</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>VkMemoryRequirements</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkBindImageMemory</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkImage</type> <name>image</name></param>
- <param devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param devicememoryoffset="1"><type>VkDeviceSize</type> <name>memoryOffset</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetImageSparseMemoryRequirements</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pSparseMemoryRequirementCount</name></param>
- <param optional="true" len="pSparseMemoryRequirementCount"><type>VkSparseImageMemoryRequirements</type>* <name>pSparseMemoryRequirements</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceSparseImageFormatProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkFormat</type> <name>format</name></param>
- <param><type>VkImageType</type> <name>type</name></param>
- <param><type>VkSampleCountFlagBits</type> <name>samples</name></param>
- <param><type>VkImageUsageFlags</type> <name>usage</name></param>
- <param><type>VkImageTiling</type> <name>tiling</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkSparseImageFormatProperties</type>* <name>pProperties</name></param>
- </command>
- <command queues="sparse_binding" successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkQueueBindSparse</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param optional="true"><type>uint32_t</type> <name>bindInfoCount</name></param>
- <param len="bindInfoCount" externsync="pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image">const <type>VkBindSparseInfo</type>* <name>pBindInfo</name></param>
- <param optional="true" externsync="true"><type>VkFence</type> <name>fence</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateFence</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkFenceCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkFence</type>* <name>pFence</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyFence</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkFence</type> <name>fence</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkResetFences</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>fenceCount</name></param>
- <param len="fenceCount" externsync="true">const <type>VkFence</type>* <name>pFences</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_NOT_READY" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkGetFenceStatus</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkFence</type> <name>fence</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkWaitForFences</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>fenceCount</name></param>
- <param len="fenceCount">const <type>VkFence</type>* <name>pFences</name></param>
- <param><type>VkBool32</type> <name>waitAll</name></param>
- <param><type>uint64_t</type> <name>timeout</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateSemaphore</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSemaphoreCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSemaphore</type>* <name>pSemaphore</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroySemaphore</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkSemaphore</type> <name>semaphore</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateEvent</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkEventCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkEvent</type>* <name>pEvent</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyEvent</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkEvent</type> <name>event</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_EVENT_SET,VK_EVENT_RESET" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkGetEventStatus</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkEvent</type> <name>event</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkSetEvent</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkEvent</type> <name>event</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkResetEvent</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkEvent</type> <name>event</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateQueryPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkQueryPoolCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkQueryPool</type>* <name>pQueryPool</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyQueryPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkQueryPool</type> <name>queryPool</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_NOT_READY" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkGetQueryPoolResults</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>firstQuery</name></param>
- <param><type>uint32_t</type> <name>queryCount</name></param>
- <param><type>size_t</type> <name>dataSize</name></param>
- <param len="dataSize"><type>void</type>* <name>pData</name></param>
- <param><type>VkDeviceSize</type> <name>stride</name></param>
- <param optional="true"><type>VkQueryResultFlags</type> <name>flags</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkResetQueryPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>firstQuery</name></param>
- <param><type>uint32_t</type> <name>queryCount</name></param>
- </command>
- <command name="vkResetQueryPoolEXT" alias="vkResetQueryPool"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR">
- <proto><type>VkResult</type> <name>vkCreateBuffer</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkBufferCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkBuffer</type>* <name>pBuffer</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyBuffer</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkBuffer</type> <name>buffer</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateBufferView</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkBufferViewCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkBufferView</type>* <name>pView</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyBufferView</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkBufferView</type> <name>bufferView</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateImage</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImageCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkImage</type>* <name>pImage</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyImage</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkImage</type> <name>image</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetImageSubresourceLayout</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param>const <type>VkImageSubresource</type>* <name>pSubresource</name></param>
- <param><type>VkSubresourceLayout</type>* <name>pLayout</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateImageView</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImageViewCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkImageView</type>* <name>pView</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyImageView</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkImageView</type> <name>imageView</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_SHADER_NV">
- <proto><type>VkResult</type> <name>vkCreateShaderModule</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkShaderModuleCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkShaderModule</type>* <name>pShaderModule</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyShaderModule</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkShaderModule</type> <name>shaderModule</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreatePipelineCache</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPipelineCacheCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkPipelineCache</type>* <name>pPipelineCache</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyPipelineCache</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkPipelineCache</type> <name>pipelineCache</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPipelineCacheData</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkPipelineCache</type> <name>pipelineCache</name></param>
- <param optional="false,true"><type>size_t</type>* <name>pDataSize</name></param>
- <param optional="true" len="pDataSize"><type>void</type>* <name>pData</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkMergePipelineCaches</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkPipelineCache</type> <name>dstCache</name></param>
- <param><type>uint32_t</type> <name>srcCacheCount</name></param>
- <param len="srcCacheCount">const <type>VkPipelineCache</type>* <name>pSrcCaches</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_PIPELINE_COMPILE_REQUIRED_EXT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_SHADER_NV">
- <proto><type>VkResult</type> <name>vkCreateGraphicsPipelines</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkPipelineCache</type> <name>pipelineCache</name></param>
- <param><type>uint32_t</type> <name>createInfoCount</name></param>
- <param len="createInfoCount">const <type>VkGraphicsPipelineCreateInfo</type>* <name>pCreateInfos</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param len="createInfoCount"><type>VkPipeline</type>* <name>pPipelines</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_PIPELINE_COMPILE_REQUIRED_EXT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_SHADER_NV">
- <proto><type>VkResult</type> <name>vkCreateComputePipelines</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkPipelineCache</type> <name>pipelineCache</name></param>
- <param><type>uint32_t</type> <name>createInfoCount</name></param>
- <param len="createInfoCount">const <type>VkComputePipelineCreateInfo</type>* <name>pCreateInfos</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param len="createInfoCount"><type>VkPipeline</type>* <name>pPipelines</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkRenderPass</type> <name>renderpass</name></param>
- <param><type>VkExtent2D</type>* <name>pMaxWorkgroupSize</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyPipeline</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkPipeline</type> <name>pipeline</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreatePipelineLayout</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPipelineLayoutCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkPipelineLayout</type>* <name>pPipelineLayout</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyPipelineLayout</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkPipelineLayout</type> <name>pipelineLayout</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateSampler</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSamplerCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSampler</type>* <name>pSampler</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroySampler</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkSampler</type> <name>sampler</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateDescriptorSetLayout</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDescriptorSetLayoutCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDescriptorSetLayout</type>* <name>pSetLayout</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyDescriptorSetLayout</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkDescriptorSetLayout</type> <name>descriptorSetLayout</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTATION_EXT">
- <proto><type>VkResult</type> <name>vkCreateDescriptorPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDescriptorPoolCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDescriptorPool</type>* <name>pDescriptorPool</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyDescriptorPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS">
- <proto><type>VkResult</type> <name>vkResetDescriptorPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></param>
- <param optional="true"><type>VkDescriptorPoolResetFlags</type> <name>flags</name></param>
- <implicitexternsyncparams>
- <param>any sname:VkDescriptorSet objects allocated from pname:descriptorPool</param>
- </implicitexternsyncparams>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTED_POOL,VK_ERROR_OUT_OF_POOL_MEMORY">
- <proto><type>VkResult</type> <name>vkAllocateDescriptorSets</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="pAllocateInfo->descriptorPool">const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param>
- <param len="pAllocateInfo->descriptorSetCount"><type>VkDescriptorSet</type>* <name>pDescriptorSets</name></param>
- </command>
- <command successcodes="VK_SUCCESS">
- <proto><type>VkResult</type> <name>vkFreeDescriptorSets</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></param>
- <param><type>uint32_t</type> <name>descriptorSetCount</name></param>
- <param noautovalidity="true" externsync="true" len="descriptorSetCount">const <type>VkDescriptorSet</type>* <name>pDescriptorSets</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkUpdateDescriptorSets</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>uint32_t</type> <name>descriptorWriteCount</name></param>
- <param len="descriptorWriteCount" externsync="pDescriptorWrites[].dstSet">const <type>VkWriteDescriptorSet</type>* <name>pDescriptorWrites</name></param>
- <param optional="true"><type>uint32_t</type> <name>descriptorCopyCount</name></param>
- <param len="descriptorCopyCount" externsync="pDescriptorCopies[].dstSet">const <type>VkCopyDescriptorSet</type>* <name>pDescriptorCopies</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateFramebuffer</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkFramebufferCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkFramebuffer</type>* <name>pFramebuffer</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyFramebuffer</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkFramebuffer</type> <name>framebuffer</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateRenderPass</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkRenderPassCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkRenderPass</type>* <name>pRenderPass</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyRenderPass</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkRenderPass</type> <name>renderPass</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetRenderAreaGranularity</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkRenderPass</type> <name>renderPass</name></param>
- <param><type>VkExtent2D</type>* <name>pGranularity</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateCommandPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkCommandPoolCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkCommandPool</type>* <name>pCommandPool</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyCommandPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkCommandPool</type> <name>commandPool</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkResetCommandPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkCommandPool</type> <name>commandPool</name></param>
- <param optional="true"><type>VkCommandPoolResetFlags</type> <name>flags</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkAllocateCommandBuffers</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="pAllocateInfo->commandPool">const <type>VkCommandBufferAllocateInfo</type>* <name>pAllocateInfo</name></param>
- <param len="pAllocateInfo->commandBufferCount"><type>VkCommandBuffer</type>* <name>pCommandBuffers</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkFreeCommandBuffers</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkCommandPool</type> <name>commandPool</name></param>
- <param><type>uint32_t</type> <name>commandBufferCount</name></param>
- <param noautovalidity="true" externsync="true" len="commandBufferCount">const <type>VkCommandBuffer</type>* <name>pCommandBuffers</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkBeginCommandBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCommandBufferBeginInfo</type>* <name>pBeginInfo</name></param>
- <implicitexternsyncparams>
- <param>the sname:VkCommandPool that pname:commandBuffer was allocated from</param>
- </implicitexternsyncparams>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkEndCommandBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <implicitexternsyncparams>
- <param>the sname:VkCommandPool that pname:commandBuffer was allocated from</param>
- </implicitexternsyncparams>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkResetCommandBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>VkCommandBufferResetFlags</type> <name>flags</name></param>
- <implicitexternsyncparams>
- <param>the sname:VkCommandPool that pname:commandBuffer was allocated from</param>
- </implicitexternsyncparams>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindPipeline</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></param>
- <param><type>VkPipeline</type> <name>pipeline</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetViewport</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstViewport</name></param>
- <param><type>uint32_t</type> <name>viewportCount</name></param>
- <param len="viewportCount">const <type>VkViewport</type>* <name>pViewports</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetScissor</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstScissor</name></param>
- <param><type>uint32_t</type> <name>scissorCount</name></param>
- <param len="scissorCount">const <type>VkRect2D</type>* <name>pScissors</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetLineWidth</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>float</type> <name>lineWidth</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDepthBias</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>float</type> <name>depthBiasConstantFactor</name></param>
- <param><type>float</type> <name>depthBiasClamp</name></param>
- <param><type>float</type> <name>depthBiasSlopeFactor</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetBlendConstants</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>float</type> <name>blendConstants</name>[4]</param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDepthBounds</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>float</type> <name>minDepthBounds</name></param>
- <param><type>float</type> <name>maxDepthBounds</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetStencilCompareMask</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkStencilFaceFlags</type> <name>faceMask</name></param>
- <param><type>uint32_t</type> <name>compareMask</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetStencilWriteMask</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkStencilFaceFlags</type> <name>faceMask</name></param>
- <param><type>uint32_t</type> <name>writeMask</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetStencilReference</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkStencilFaceFlags</type> <name>faceMask</name></param>
- <param><type>uint32_t</type> <name>reference</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindDescriptorSets</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></param>
- <param><type>VkPipelineLayout</type> <name>layout</name></param>
- <param><type>uint32_t</type> <name>firstSet</name></param>
- <param><type>uint32_t</type> <name>descriptorSetCount</name></param>
- <param len="descriptorSetCount">const <type>VkDescriptorSet</type>* <name>pDescriptorSets</name></param>
- <param optional="true"><type>uint32_t</type> <name>dynamicOffsetCount</name></param>
- <param len="dynamicOffsetCount">const <type>uint32_t</type>* <name>pDynamicOffsets</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindIndexBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>VkIndexType</type> <name>indexType</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindVertexBuffers</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstBinding</name></param>
- <param><type>uint32_t</type> <name>bindingCount</name></param>
- <param len="bindingCount">const <type>VkBuffer</type>* <name>pBuffers</name></param>
- <param len="bindingCount">const <type>VkDeviceSize</type>* <name>pOffsets</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDraw</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>vertexCount</name></param>
- <param><type>uint32_t</type> <name>instanceCount</name></param>
- <param><type>uint32_t</type> <name>firstVertex</name></param>
- <param><type>uint32_t</type> <name>firstInstance</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawIndexed</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>indexCount</name></param>
- <param><type>uint32_t</type> <name>instanceCount</name></param>
- <param><type>uint32_t</type> <name>firstIndex</name></param>
- <param><type>int32_t</type> <name>vertexOffset</name></param>
- <param><type>uint32_t</type> <name>firstInstance</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawMultiEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>uint32_t</type> <name>drawCount</name></param>
- <param noautovalidity="true" len="drawCount">const <type>VkMultiDrawInfoEXT</type>* <name>pVertexInfo</name></param>
- <param><type>uint32_t</type> <name>instanceCount</name></param>
- <param><type>uint32_t</type> <name>firstInstance</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawMultiIndexedEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>uint32_t</type> <name>drawCount</name></param>
- <param noautovalidity="true" len="drawCount">const <type>VkMultiDrawIndexedInfoEXT</type>* <name>pIndexInfo</name></param>
- <param><type>uint32_t</type> <name>instanceCount</name></param>
- <param><type>uint32_t</type> <name>firstInstance</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- <param optional="true">const <type>int32_t</type>* <name>pVertexOffset</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawIndirect</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>uint32_t</type> <name>drawCount</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawIndexedIndirect</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>uint32_t</type> <name>drawCount</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDispatch</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>groupCountX</name></param>
- <param><type>uint32_t</type> <name>groupCountY</name></param>
- <param><type>uint32_t</type> <name>groupCountZ</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDispatchIndirect</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSubpassShadingHUAWEI</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>srcBuffer</name></param>
- <param><type>VkBuffer</type> <name>dstBuffer</name></param>
- <param><type>uint32_t</type> <name>regionCount</name></param>
- <param len="regionCount">const <type>VkBufferCopy</type>* <name>pRegions</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyImage</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkImage</type> <name>srcImage</name></param>
- <param><type>VkImageLayout</type> <name>srcImageLayout</name></param>
- <param><type>VkImage</type> <name>dstImage</name></param>
- <param><type>VkImageLayout</type> <name>dstImageLayout</name></param>
- <param><type>uint32_t</type> <name>regionCount</name></param>
- <param len="regionCount">const <type>VkImageCopy</type>* <name>pRegions</name></param>
- </command>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBlitImage</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkImage</type> <name>srcImage</name></param>
- <param><type>VkImageLayout</type> <name>srcImageLayout</name></param>
- <param><type>VkImage</type> <name>dstImage</name></param>
- <param><type>VkImageLayout</type> <name>dstImageLayout</name></param>
- <param><type>uint32_t</type> <name>regionCount</name></param>
- <param len="regionCount">const <type>VkImageBlit</type>* <name>pRegions</name></param>
- <param><type>VkFilter</type> <name>filter</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyBufferToImage</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>srcBuffer</name></param>
- <param><type>VkImage</type> <name>dstImage</name></param>
- <param><type>VkImageLayout</type> <name>dstImageLayout</name></param>
- <param><type>uint32_t</type> <name>regionCount</name></param>
- <param len="regionCount">const <type>VkBufferImageCopy</type>* <name>pRegions</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyImageToBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkImage</type> <name>srcImage</name></param>
- <param><type>VkImageLayout</type> <name>srcImageLayout</name></param>
- <param><type>VkBuffer</type> <name>dstBuffer</name></param>
- <param><type>uint32_t</type> <name>regionCount</name></param>
- <param len="regionCount">const <type>VkBufferImageCopy</type>* <name>pRegions</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdUpdateBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>dstBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>dstOffset</name></param>
- <param><type>VkDeviceSize</type> <name>dataSize</name></param>
- <param len="dataSize">const <type>void</type>* <name>pData</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary" comment="transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification">
- <proto><type>void</type> <name>vkCmdFillBuffer</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>dstBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>dstOffset</name></param>
- <param><type>VkDeviceSize</type> <name>size</name></param>
- <param><type>uint32_t</type> <name>data</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdClearColorImage</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>VkImageLayout</type> <name>imageLayout</name></param>
- <param>const <type>VkClearColorValue</type>* <name>pColor</name></param>
- <param><type>uint32_t</type> <name>rangeCount</name></param>
- <param len="rangeCount">const <type>VkImageSubresourceRange</type>* <name>pRanges</name></param>
- </command>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdClearDepthStencilImage</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>VkImageLayout</type> <name>imageLayout</name></param>
- <param>const <type>VkClearDepthStencilValue</type>* <name>pDepthStencil</name></param>
- <param><type>uint32_t</type> <name>rangeCount</name></param>
- <param len="rangeCount">const <type>VkImageSubresourceRange</type>* <name>pRanges</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdClearAttachments</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>attachmentCount</name></param>
- <param len="attachmentCount">const <type>VkClearAttachment</type>* <name>pAttachments</name></param>
- <param><type>uint32_t</type> <name>rectCount</name></param>
- <param len="rectCount">const <type>VkClearRect</type>* <name>pRects</name></param>
- </command>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdResolveImage</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkImage</type> <name>srcImage</name></param>
- <param><type>VkImageLayout</type> <name>srcImageLayout</name></param>
- <param><type>VkImage</type> <name>dstImage</name></param>
- <param><type>VkImageLayout</type> <name>dstImageLayout</name></param>
- <param><type>uint32_t</type> <name>regionCount</name></param>
- <param len="regionCount">const <type>VkImageResolve</type>* <name>pRegions</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetEvent</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkEvent</type> <name>event</name></param>
- <param optional="true"><type>VkPipelineStageFlags</type> <name>stageMask</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdResetEvent</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkEvent</type> <name>event</name></param>
- <param optional="true"><type>VkPipelineStageFlags</type> <name>stageMask</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWaitEvents</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>eventCount</name></param>
- <param len="eventCount">const <type>VkEvent</type>* <name>pEvents</name></param>
- <param optional="true"><type>VkPipelineStageFlags</type> <name>srcStageMask</name></param>
- <param optional="true"><type>VkPipelineStageFlags</type> <name>dstStageMask</name></param>
- <param optional="true"><type>uint32_t</type> <name>memoryBarrierCount</name></param>
- <param len="memoryBarrierCount">const <type>VkMemoryBarrier</type>* <name>pMemoryBarriers</name></param>
- <param optional="true"><type>uint32_t</type> <name>bufferMemoryBarrierCount</name></param>
- <param len="bufferMemoryBarrierCount">const <type>VkBufferMemoryBarrier</type>* <name>pBufferMemoryBarriers</name></param>
- <param optional="true"><type>uint32_t</type> <name>imageMemoryBarrierCount</name></param>
- <param len="imageMemoryBarrierCount">const <type>VkImageMemoryBarrier</type>* <name>pImageMemoryBarriers</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdPipelineBarrier</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>VkPipelineStageFlags</type> <name>srcStageMask</name></param>
- <param optional="true"><type>VkPipelineStageFlags</type> <name>dstStageMask</name></param>
- <param optional="true"><type>VkDependencyFlags</type> <name>dependencyFlags</name></param>
- <param optional="true"><type>uint32_t</type> <name>memoryBarrierCount</name></param>
- <param len="memoryBarrierCount">const <type>VkMemoryBarrier</type>* <name>pMemoryBarriers</name></param>
- <param optional="true"><type>uint32_t</type> <name>bufferMemoryBarrierCount</name></param>
- <param len="bufferMemoryBarrierCount">const <type>VkBufferMemoryBarrier</type>* <name>pBufferMemoryBarriers</name></param>
- <param optional="true"><type>uint32_t</type> <name>imageMemoryBarrierCount</name></param>
- <param len="imageMemoryBarrierCount">const <type>VkImageMemoryBarrier</type>* <name>pImageMemoryBarriers</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBeginQuery</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>query</name></param>
- <param optional="true"><type>VkQueryControlFlags</type> <name>flags</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdEndQuery</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>query</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBeginConditionalRenderingEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkConditionalRenderingBeginInfoEXT</type>* <name>pConditionalRenderingBegin</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdEndConditionalRenderingEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdResetQueryPool</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>firstQuery</name></param>
- <param><type>uint32_t</type> <name>queryCount</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWriteTimestamp</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineStageFlagBits</type> <name>pipelineStage</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>query</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyQueryPoolResults</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>firstQuery</name></param>
- <param><type>uint32_t</type> <name>queryCount</name></param>
- <param><type>VkBuffer</type> <name>dstBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>dstOffset</name></param>
- <param><type>VkDeviceSize</type> <name>stride</name></param>
- <param optional="true"><type>VkQueryResultFlags</type> <name>flags</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdPushConstants</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineLayout</type> <name>layout</name></param>
- <param><type>VkShaderStageFlags</type> <name>stageFlags</name></param>
- <param><type>uint32_t</type> <name>offset</name></param>
- <param><type>uint32_t</type> <name>size</name></param>
- <param len="size">const <type>void</type>* <name>pValues</name></param>
- </command>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdBeginRenderPass</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkRenderPassBeginInfo</type>* <name>pRenderPassBegin</name></param>
- <param><type>VkSubpassContents</type> <name>contents</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdNextSubpass</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkSubpassContents</type> <name>contents</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdEndRenderPass</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdExecuteCommands</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>commandBufferCount</name></param>
- <param len="commandBufferCount">const <type>VkCommandBuffer</type>* <name>pCommandBuffers</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
- <proto><type>VkResult</type> <name>vkCreateAndroidSurfaceKHR</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkAndroidSurfaceCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceDisplayPropertiesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkDisplayPropertiesKHR</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceDisplayPlanePropertiesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkDisplayPlanePropertiesKHR</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetDisplayPlaneSupportedDisplaysKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>planeIndex</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pDisplayCount</name></param>
- <param optional="true" len="pDisplayCount"><type>VkDisplayKHR</type>* <name>pDisplays</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetDisplayModePropertiesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkDisplayModePropertiesKHR</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkCreateDisplayModeKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param externsync="true"><type>VkDisplayKHR</type> <name>display</name></param>
- <param>const <type>VkDisplayModeCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDisplayModeKHR</type>* <name>pMode</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetDisplayPlaneCapabilitiesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param externsync="true"><type>VkDisplayModeKHR</type> <name>mode</name></param>
- <param><type>uint32_t</type> <name>planeIndex</name></param>
- <param><type>VkDisplayPlaneCapabilitiesKHR</type>* <name>pCapabilities</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateDisplayPlaneSurfaceKHR</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkDisplaySurfaceCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,VK_ERROR_DEVICE_LOST,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkCreateSharedSwapchainsKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>swapchainCount</name></param>
- <param len="swapchainCount" externsync="pCreateInfos[].surface,pCreateInfos[].oldSwapchain">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfos</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param len="swapchainCount"><type>VkSwapchainKHR</type>* <name>pSwapchains</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroySurfaceKHR</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param optional="true" externsync="true"><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfaceSupportKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param><type>VkBool32</type>* <name>pSupported</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfaceCapabilitiesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param><type>VkSurfaceCapabilitiesKHR</type>* <name>pSurfaceCapabilities</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfaceFormatsKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pSurfaceFormatCount</name></param>
- <param optional="true" len="pSurfaceFormatCount"><type>VkSurfaceFormatKHR</type>* <name>pSurfaceFormats</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfacePresentModesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPresentModeCount</name></param>
- <param optional="true" len="pPresentModeCount"><type>VkPresentModeKHR</type>* <name>pPresentModes</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkCreateSwapchainKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="pCreateInfo->surface,pCreateInfo->oldSwapchain">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSwapchainKHR</type>* <name>pSwapchain</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroySwapchainKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetSwapchainImagesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pSwapchainImageCount</name></param>
- <param optional="true" len="pSwapchainImageCount"><type>VkImage</type>* <name>pSwapchainImages</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_TIMEOUT,VK_NOT_READY,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT">
- <proto><type>VkResult</type> <name>vkAcquireNextImageKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param><type>uint64_t</type> <name>timeout</name></param>
- <param optional="true" externsync="true"><type>VkSemaphore</type> <name>semaphore</name></param>
- <param optional="true" externsync="true"><type>VkFence</type> <name>fence</name></param>
- <param><type>uint32_t</type>* <name>pImageIndex</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT">
- <proto><type>VkResult</type> <name>vkQueuePresentKHR</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param externsync="pPresentInfo->pWaitSemaphores[],pPresentInfo->pSwapchains[]">const <type>VkPresentInfoKHR</type>* <name>pPresentInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
- <proto><type>VkResult</type> <name>vkCreateViSurfaceNN</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkViSurfaceCreateInfoNN</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateWaylandSurfaceKHR</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkWaylandSurfaceCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command>
- <proto><type>VkBool32</type> <name>vkGetPhysicalDeviceWaylandPresentationSupportKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param>struct <type>wl_display</type>* <name>display</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateWin32SurfaceKHR</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkWin32SurfaceCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command>
- <proto><type>VkBool32</type> <name>vkGetPhysicalDeviceWin32PresentationSupportKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateXlibSurfaceKHR</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkXlibSurfaceCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command>
- <proto><type>VkBool32</type> <name>vkGetPhysicalDeviceXlibPresentationSupportKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param><type>Display</type>* <name>dpy</name></param>
- <param><type>VisualID</type> <name>visualID</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateXcbSurfaceKHR</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkXcbSurfaceCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command>
- <proto><type>VkBool32</type> <name>vkGetPhysicalDeviceXcbPresentationSupportKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param><type>xcb_connection_t</type>* <name>connection</name></param>
- <param><type>xcb_visualid_t</type> <name>visual_id</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateDirectFBSurfaceEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkDirectFBSurfaceCreateInfoEXT</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command>
- <proto><type>VkBool32</type> <name>vkGetPhysicalDeviceDirectFBPresentationSupportEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param><type>IDirectFB</type>* <name>dfb</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateImagePipeSurfaceFUCHSIA</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkImagePipeSurfaceCreateInfoFUCHSIA</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
- <proto><type>VkResult</type> <name>vkCreateStreamDescriptorSurfaceGGP</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkStreamDescriptorSurfaceCreateInfoGGP</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateScreenSurfaceQNX</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkScreenSurfaceCreateInfoQNX</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command>
- <proto><type>VkBool32</type> <name>vkGetPhysicalDeviceScreenPresentationSupportQNX</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param>struct <type>_screen_window</type>* <name>window</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateDebugReportCallbackEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkDebugReportCallbackCreateInfoEXT</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDebugReportCallbackEXT</type>* <name>pCallback</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyDebugReportCallbackEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param optional="true" externsync="true"><type>VkDebugReportCallbackEXT</type> <name>callback</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDebugReportMessageEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param><type>VkDebugReportFlagsEXT</type> <name>flags</name></param>
- <param><type>VkDebugReportObjectTypeEXT</type> <name>objectType</name></param>
- <param objecttype="objectType"><type>uint64_t</type> <name>object</name></param>
- <param><type>size_t</type> <name>location</name></param>
- <param><type>int32_t</type> <name>messageCode</name></param>
- <param len="null-terminated">const <type>char</type>* <name>pLayerPrefix</name></param>
- <param len="null-terminated">const <type>char</type>* <name>pMessage</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkDebugMarkerSetObjectNameEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="pNameInfo->object">const <type>VkDebugMarkerObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkDebugMarkerSetObjectTagEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="pTagInfo->object">const <type>VkDebugMarkerObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDebugMarkerBeginEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkDebugMarkerMarkerInfoEXT</type>* <name>pMarkerInfo</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDebugMarkerEndEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDebugMarkerInsertEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkDebugMarkerMarkerInfoEXT</type>* <name>pMarkerInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FORMAT_NOT_SUPPORTED">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceExternalImageFormatPropertiesNV</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkFormat</type> <name>format</name></param>
- <param><type>VkImageType</type> <name>type</name></param>
- <param><type>VkImageTiling</type> <name>tiling</name></param>
- <param><type>VkImageUsageFlags</type> <name>usage</name></param>
- <param optional="true"><type>VkImageCreateFlags</type> <name>flags</name></param>
- <param optional="true"><type>VkExternalMemoryHandleTypeFlagsNV</type> <name>externalHandleType</name></param>
- <param><type>VkExternalImageFormatPropertiesNV</type>* <name>pExternalImageFormatProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetMemoryWin32HandleNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param><type>VkExternalMemoryHandleTypeFlagsNV</type> <name>handleType</name></param>
- <param><type>HANDLE</type>* <name>pHandle</name></param>
- </command>
- <command queues="graphics,compute" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdExecuteGeneratedCommandsNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>isPreprocessed</name></param>
- <param>const <type>VkGeneratedCommandsInfoNV</type>* <name>pGeneratedCommandsInfo</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdPreprocessGeneratedCommandsNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkGeneratedCommandsInfoNV</type>* <name>pGeneratedCommandsInfo</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindPipelineShaderGroupNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></param>
- <param><type>VkPipeline</type> <name>pipeline</name></param>
- <param><type>uint32_t</type> <name>groupIndex</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetGeneratedCommandsMemoryRequirementsNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkGeneratedCommandsMemoryRequirementsInfoNV</type>* <name>pInfo</name></param>
- <param><type>VkMemoryRequirements2</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateIndirectCommandsLayoutNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkIndirectCommandsLayoutCreateInfoNV</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkIndirectCommandsLayoutNV</type>* <name>pIndirectCommandsLayout</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyIndirectCommandsLayoutNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkIndirectCommandsLayoutNV</type> <name>indirectCommandsLayout</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceFeatures2</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkPhysicalDeviceFeatures2</type>* <name>pFeatures</name></param>
- </command>
- <command name="vkGetPhysicalDeviceFeatures2KHR" alias="vkGetPhysicalDeviceFeatures2"/>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceProperties2</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkPhysicalDeviceProperties2</type>* <name>pProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceProperties2KHR" alias="vkGetPhysicalDeviceProperties2"/>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceFormatProperties2</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkFormat</type> <name>format</name></param>
- <param><type>VkFormatProperties2</type>* <name>pFormatProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceFormatProperties2KHR" alias="vkGetPhysicalDeviceFormatProperties2"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FORMAT_NOT_SUPPORTED">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceImageFormatProperties2</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceImageFormatInfo2</type>* <name>pImageFormatInfo</name></param>
- <param><type>VkImageFormatProperties2</type>* <name>pImageFormatProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceImageFormatProperties2KHR" alias="vkGetPhysicalDeviceImageFormatProperties2"/>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceQueueFamilyProperties2</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pQueueFamilyPropertyCount</name></param>
- <param optional="true" len="pQueueFamilyPropertyCount"><type>VkQueueFamilyProperties2</type>* <name>pQueueFamilyProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceQueueFamilyProperties2KHR" alias="vkGetPhysicalDeviceQueueFamilyProperties2"/>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceMemoryProperties2</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkPhysicalDeviceMemoryProperties2</type>* <name>pMemoryProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceMemoryProperties2KHR" alias="vkGetPhysicalDeviceMemoryProperties2"/>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceSparseImageFormatProperties2</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceSparseImageFormatInfo2</type>* <name>pFormatInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkSparseImageFormatProperties2</type>* <name>pProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceSparseImageFormatProperties2KHR" alias="vkGetPhysicalDeviceSparseImageFormatProperties2"/>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdPushDescriptorSetKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></param>
- <param><type>VkPipelineLayout</type> <name>layout</name></param>
- <param><type>uint32_t</type> <name>set</name></param>
- <param><type>uint32_t</type> <name>descriptorWriteCount</name></param>
- <param len="descriptorWriteCount">const <type>VkWriteDescriptorSet</type>* <name>pDescriptorWrites</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkTrimCommandPool</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkCommandPool</type> <name>commandPool</name></param>
- <param optional="true"><type>VkCommandPoolTrimFlags</type> <name>flags</name></param>
- </command>
- <command name="vkTrimCommandPoolKHR" alias="vkTrimCommandPool"/>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceExternalBufferProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceExternalBufferInfo</type>* <name>pExternalBufferInfo</name></param>
- <param><type>VkExternalBufferProperties</type>* <name>pExternalBufferProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceExternalBufferPropertiesKHR" alias="vkGetPhysicalDeviceExternalBufferProperties"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetMemoryWin32HandleKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkMemoryGetWin32HandleInfoKHR</type>* <name>pGetWin32HandleInfo</name></param>
- <param><type>HANDLE</type>* <name>pHandle</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkGetMemoryWin32HandlePropertiesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></param>
- <param><type>HANDLE</type> <name>handle</name></param>
- <param><type>VkMemoryWin32HandlePropertiesKHR</type>* <name>pMemoryWin32HandleProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetMemoryFdKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkMemoryGetFdInfoKHR</type>* <name>pGetFdInfo</name></param>
- <param><type>int</type>* <name>pFd</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkGetMemoryFdPropertiesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></param>
- <param><type>int</type> <name>fd</name></param>
- <param><type>VkMemoryFdPropertiesKHR</type>* <name>pMemoryFdProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetMemoryZirconHandleFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkMemoryGetZirconHandleInfoFUCHSIA</type>* <name>pGetZirconHandleInfo</name></param>
- <param><type>zx_handle_t</type>* <name>pZirconHandle</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkGetMemoryZirconHandlePropertiesFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></param>
- <param><type>zx_handle_t</type> <name>zirconHandle</name></param>
- <param><type>VkMemoryZirconHandlePropertiesFUCHSIA</type>* <name>pMemoryZirconHandleProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkGetMemoryRemoteAddressNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkMemoryGetRemoteAddressInfoNV</type>* <name>pMemoryGetRemoteAddressInfo</name></param>
- <param><type>VkRemoteAddressNV</type>* <name>pAddress</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceExternalSemaphoreProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceExternalSemaphoreInfo</type>* <name>pExternalSemaphoreInfo</name></param>
- <param><type>VkExternalSemaphoreProperties</type>* <name>pExternalSemaphoreProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" alias="vkGetPhysicalDeviceExternalSemaphoreProperties"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetSemaphoreWin32HandleKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSemaphoreGetWin32HandleInfoKHR</type>* <name>pGetWin32HandleInfo</name></param>
- <param><type>HANDLE</type>* <name>pHandle</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkImportSemaphoreWin32HandleKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImportSemaphoreWin32HandleInfoKHR</type>* <name>pImportSemaphoreWin32HandleInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetSemaphoreFdKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSemaphoreGetFdInfoKHR</type>* <name>pGetFdInfo</name></param>
- <param><type>int</type>* <name>pFd</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkImportSemaphoreFdKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImportSemaphoreFdInfoKHR</type>* <name>pImportSemaphoreFdInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetSemaphoreZirconHandleFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSemaphoreGetZirconHandleInfoFUCHSIA</type>* <name>pGetZirconHandleInfo</name></param>
- <param><type>zx_handle_t</type>* <name>pZirconHandle</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkImportSemaphoreZirconHandleFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImportSemaphoreZirconHandleInfoFUCHSIA</type>* <name>pImportSemaphoreZirconHandleInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceExternalFenceProperties</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceExternalFenceInfo</type>* <name>pExternalFenceInfo</name></param>
- <param><type>VkExternalFenceProperties</type>* <name>pExternalFenceProperties</name></param>
- </command>
- <command name="vkGetPhysicalDeviceExternalFencePropertiesKHR" alias="vkGetPhysicalDeviceExternalFenceProperties"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetFenceWin32HandleKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkFenceGetWin32HandleInfoKHR</type>* <name>pGetWin32HandleInfo</name></param>
- <param><type>HANDLE</type>* <name>pHandle</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkImportFenceWin32HandleKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImportFenceWin32HandleInfoKHR</type>* <name>pImportFenceWin32HandleInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetFenceFdKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkFenceGetFdInfoKHR</type>* <name>pGetFdInfo</name></param>
- <param><type>int</type>* <name>pFd</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkImportFenceFdKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImportFenceFdInfoKHR</type>* <name>pImportFenceFdInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS">
- <proto><type>VkResult</type> <name>vkReleaseDisplayEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkAcquireXlibDisplayEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>Display</type>* <name>dpy</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetRandROutputDisplayEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>Display</type>* <name>dpy</name></param>
- <param><type>RROutput</type> <name>rrOutput</name></param>
- <param><type>VkDisplayKHR</type>* <name>pDisplay</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkAcquireWinrtDisplayNV</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkGetWinrtDisplayNV</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>deviceRelativeId</name></param>
- <param><type>VkDisplayKHR</type>* <name>pDisplay</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkDisplayPowerControlEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- <param>const <type>VkDisplayPowerInfoEXT</type>* <name>pDisplayPowerInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkRegisterDeviceEventEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDeviceEventInfoEXT</type>* <name>pDeviceEventInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkFence</type>* <name>pFence</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkRegisterDisplayEventEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- <param>const <type>VkDisplayEventInfoEXT</type>* <name>pDisplayEventInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkFence</type>* <name>pFence</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR">
- <proto><type>VkResult</type> <name>vkGetSwapchainCounterEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param><type>VkSurfaceCounterFlagBitsEXT</type> <name>counter</name></param>
- <param><type>uint64_t</type>* <name>pCounterValue</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfaceCapabilities2EXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param><type>VkSurfaceCapabilities2EXT</type>* <name>pSurfaceCapabilities</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkEnumeratePhysicalDeviceGroups</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPhysicalDeviceGroupCount</name></param>
- <param optional="true" len="pPhysicalDeviceGroupCount"><type>VkPhysicalDeviceGroupProperties</type>* <name>pPhysicalDeviceGroupProperties</name></param>
- </command>
- <command name="vkEnumeratePhysicalDeviceGroupsKHR" alias="vkEnumeratePhysicalDeviceGroups"/>
- <command>
- <proto><type>void</type> <name>vkGetDeviceGroupPeerMemoryFeatures</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>heapIndex</name></param>
- <param><type>uint32_t</type> <name>localDeviceIndex</name></param>
- <param><type>uint32_t</type> <name>remoteDeviceIndex</name></param>
- <param><type>VkPeerMemoryFeatureFlags</type>* <name>pPeerMemoryFeatures</name></param>
- </command>
- <command name="vkGetDeviceGroupPeerMemoryFeaturesKHR" alias="vkGetDeviceGroupPeerMemoryFeatures"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR">
- <proto><type>VkResult</type> <name>vkBindBufferMemory2</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>bindInfoCount</name></param>
- <param len="bindInfoCount">const <type>VkBindBufferMemoryInfo</type>* <name>pBindInfos</name></param>
- </command>
- <command name="vkBindBufferMemory2KHR" alias="vkBindBufferMemory2"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkBindImageMemory2</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>bindInfoCount</name></param>
- <param len="bindInfoCount">const <type>VkBindImageMemoryInfo</type>* <name>pBindInfos</name></param>
- </command>
- <command name="vkBindImageMemory2KHR" alias="vkBindImageMemory2"/>
- <command queues="graphics,compute,transfer" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDeviceMask</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>deviceMask</name></param>
- </command>
- <command name="vkCmdSetDeviceMaskKHR" alias="vkCmdSetDeviceMask"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetDeviceGroupPresentCapabilitiesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkDeviceGroupPresentCapabilitiesKHR</type>* <name>pDeviceGroupPresentCapabilities</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetDeviceGroupSurfacePresentModesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param optional="false,true"><type>VkDeviceGroupPresentModeFlagsKHR</type>* <name>pModes</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_TIMEOUT,VK_NOT_READY,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT">
- <proto><type>VkResult</type> <name>vkAcquireNextImage2KHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkAcquireNextImageInfoKHR</type>* <name>pAcquireInfo</name></param>
- <param><type>uint32_t</type>* <name>pImageIndex</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDispatchBase</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>baseGroupX</name></param>
- <param><type>uint32_t</type> <name>baseGroupY</name></param>
- <param><type>uint32_t</type> <name>baseGroupZ</name></param>
- <param><type>uint32_t</type> <name>groupCountX</name></param>
- <param><type>uint32_t</type> <name>groupCountY</name></param>
- <param><type>uint32_t</type> <name>groupCountZ</name></param>
- </command>
- <command name="vkCmdDispatchBaseKHR" alias="vkCmdDispatchBase"/>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDevicePresentRectanglesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param externsync="true"><type>VkSurfaceKHR</type> <name>surface</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pRectCount</name></param>
- <param optional="true" len="pRectCount"><type>VkRect2D</type>* <name>pRects</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateDescriptorUpdateTemplate</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDescriptorUpdateTemplateCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDescriptorUpdateTemplate</type>* <name>pDescriptorUpdateTemplate</name></param>
- </command>
- <command name="vkCreateDescriptorUpdateTemplateKHR" alias="vkCreateDescriptorUpdateTemplate"/>
- <command>
- <proto><type>void</type> <name>vkDestroyDescriptorUpdateTemplate</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkDescriptorUpdateTemplate</type> <name>descriptorUpdateTemplate</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command name="vkDestroyDescriptorUpdateTemplateKHR" alias="vkDestroyDescriptorUpdateTemplate"/>
- <command>
- <proto><type>void</type> <name>vkUpdateDescriptorSetWithTemplate</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkDescriptorSet</type> <name>descriptorSet</name></param>
- <param><type>VkDescriptorUpdateTemplate</type> <name>descriptorUpdateTemplate</name></param>
- <param noautovalidity="true">const <type>void</type>* <name>pData</name></param>
- </command>
- <command name="vkUpdateDescriptorSetWithTemplateKHR" alias="vkUpdateDescriptorSetWithTemplate"/>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdPushDescriptorSetWithTemplateKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkDescriptorUpdateTemplate</type> <name>descriptorUpdateTemplate</name></param>
- <param><type>VkPipelineLayout</type> <name>layout</name></param>
- <param><type>uint32_t</type> <name>set</name></param>
- <param noautovalidity="true">const <type>void</type>* <name>pData</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkSetHdrMetadataEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>swapchainCount</name></param>
- <param len="swapchainCount">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name></param>
- <param len="swapchainCount">const <type>VkHdrMetadataEXT</type>* <name>pMetadata</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT">
- <proto><type>VkResult</type> <name>vkGetSwapchainStatusKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetRefreshCycleDurationGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param><type>VkRefreshCycleDurationGOOGLE</type>* <name>pDisplayTimingProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPastPresentationTimingGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPresentationTimingCount</name></param>
- <param optional="true" len="pPresentationTimingCount"><type>VkPastPresentationTimingGOOGLE</type>* <name>pPresentationTimings</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
- <proto><type>VkResult</type> <name>vkCreateIOSSurfaceMVK</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkIOSSurfaceCreateInfoMVK</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
- <proto><type>VkResult</type> <name>vkCreateMacOSSurfaceMVK</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkMacOSSurfaceCreateInfoMVK</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
- <proto><type>VkResult</type> <name>vkCreateMetalSurfaceEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkMetalSurfaceCreateInfoEXT</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetViewportWScalingNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstViewport</name></param>
- <param><type>uint32_t</type> <name>viewportCount</name></param>
- <param len="viewportCount">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDiscardRectangleEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstDiscardRectangle</name></param>
- <param><type>uint32_t</type> <name>discardRectangleCount</name></param>
- <param len="discardRectangleCount">const <type>VkRect2D</type>* <name>pDiscardRectangles</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetSampleLocationsEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkSampleLocationsInfoEXT</type>* <name>pSampleLocationsInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceMultisamplePropertiesEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkSampleCountFlagBits</type> <name>samples</name></param>
- <param><type>VkMultisamplePropertiesEXT</type>* <name>pMultisampleProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfaceCapabilities2KHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceSurfaceInfo2KHR</type>* <name>pSurfaceInfo</name></param>
- <param><type>VkSurfaceCapabilities2KHR</type>* <name>pSurfaceCapabilities</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfaceFormats2KHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceSurfaceInfo2KHR</type>* <name>pSurfaceInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pSurfaceFormatCount</name></param>
- <param optional="true" len="pSurfaceFormatCount"><type>VkSurfaceFormat2KHR</type>* <name>pSurfaceFormats</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceDisplayProperties2KHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkDisplayProperties2KHR</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceDisplayPlaneProperties2KHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkDisplayPlaneProperties2KHR</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetDisplayModeProperties2KHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkDisplayModeProperties2KHR</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetDisplayPlaneCapabilities2KHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkDisplayPlaneInfo2KHR</type>* <name>pDisplayPlaneInfo</name></param>
- <param><type>VkDisplayPlaneCapabilities2KHR</type>* <name>pCapabilities</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetBufferMemoryRequirements2</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkBufferMemoryRequirementsInfo2</type>* <name>pInfo</name></param>
- <param><type>VkMemoryRequirements2</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command name="vkGetBufferMemoryRequirements2KHR" alias="vkGetBufferMemoryRequirements2"/>
- <command>
- <proto><type>void</type> <name>vkGetImageMemoryRequirements2</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImageMemoryRequirementsInfo2</type>* <name>pInfo</name></param>
- <param><type>VkMemoryRequirements2</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command name="vkGetImageMemoryRequirements2KHR" alias="vkGetImageMemoryRequirements2"/>
- <command>
- <proto><type>void</type> <name>vkGetImageSparseMemoryRequirements2</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImageSparseMemoryRequirementsInfo2</type>* <name>pInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pSparseMemoryRequirementCount</name></param>
- <param optional="true" len="pSparseMemoryRequirementCount"><type>VkSparseImageMemoryRequirements2</type>* <name>pSparseMemoryRequirements</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetDeviceBufferMemoryRequirementsKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDeviceBufferMemoryRequirementsKHR</type>* <name>pInfo</name></param>
- <param><type>VkMemoryRequirements2</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetDeviceImageMemoryRequirementsKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDeviceImageMemoryRequirementsKHR</type>* <name>pInfo</name></param>
- <param><type>VkMemoryRequirements2</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetDeviceImageSparseMemoryRequirementsKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDeviceImageMemoryRequirementsKHR</type>* <name>pInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pSparseMemoryRequirementCount</name></param>
- <param optional="true" len="pSparseMemoryRequirementCount"><type>VkSparseImageMemoryRequirements2</type>* <name>pSparseMemoryRequirements</name></param>
- </command>
- <command name="vkGetImageSparseMemoryRequirements2KHR" alias="vkGetImageSparseMemoryRequirements2"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateSamplerYcbcrConversion</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSamplerYcbcrConversionCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSamplerYcbcrConversion</type>* <name>pYcbcrConversion</name></param>
- </command>
- <command name="vkCreateSamplerYcbcrConversionKHR" alias="vkCreateSamplerYcbcrConversion"/>
- <command>
- <proto><type>void</type> <name>vkDestroySamplerYcbcrConversion</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkSamplerYcbcrConversion</type> <name>ycbcrConversion</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command name="vkDestroySamplerYcbcrConversionKHR" alias="vkDestroySamplerYcbcrConversion"/>
- <command>
- <proto><type>void</type> <name>vkGetDeviceQueue2</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDeviceQueueInfo2</type>* <name>pQueueInfo</name></param>
- <param><type>VkQueue</type>* <name>pQueue</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateValidationCacheEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkValidationCacheCreateInfoEXT</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkValidationCacheEXT</type>* <name>pValidationCache</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyValidationCacheEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkValidationCacheEXT</type> <name>validationCache</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetValidationCacheDataEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkValidationCacheEXT</type> <name>validationCache</name></param>
- <param optional="false,true"><type>size_t</type>* <name>pDataSize</name></param>
- <param optional="true" len="pDataSize"><type>void</type>* <name>pData</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkMergeValidationCachesEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkValidationCacheEXT</type> <name>dstCache</name></param>
- <param><type>uint32_t</type> <name>srcCacheCount</name></param>
- <param len="srcCacheCount">const <type>VkValidationCacheEXT</type>* <name>pSrcCaches</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetDescriptorSetLayoutSupport</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDescriptorSetLayoutCreateInfo</type>* <name>pCreateInfo</name></param>
- <param><type>VkDescriptorSetLayoutSupport</type>* <name>pSupport</name></param>
- </command>
- <command name="vkGetDescriptorSetLayoutSupportKHR" alias="vkGetDescriptorSetLayoutSupport"/>
- <command>
- <proto><type>VkResult</type> <name>vkGetSwapchainGrallocUsageANDROID</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkFormat</type> <name>format</name></param>
- <param><type>VkImageUsageFlags</type> <name>imageUsage</name></param>
- <param><type>int</type>* <name>grallocUsage</name></param>
- </command>
- <command>
- <proto><type>VkResult</type> <name>vkAcquireImageANDROID</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>int</type> <name>nativeFenceFd</name></param>
- <param><type>VkSemaphore</type> <name>semaphore</name></param>
- <param><type>VkFence</type> <name>fence</name></param>
- </command>
- <command>
- <proto><type>VkResult</type> <name>vkQueueSignalReleaseImageANDROID</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- <param optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></param>
- <param noautovalidity="true" len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>int</type>* <name>pNativeFenceFd</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_FEATURE_NOT_PRESENT,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetShaderInfoAMD</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkPipeline</type> <name>pipeline</name></param>
- <param><type>VkShaderStageFlagBits</type> <name>shaderStage</name></param>
- <param><type>VkShaderInfoTypeAMD</type> <name>infoType</name></param>
- <param optional="false,true"><type>size_t</type>* <name>pInfoSize</name></param>
- <param optional="true" len="pInfoSize"><type>void</type>* <name>pInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkSetLocalDimmingAMD</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkSwapchainKHR</type> <name>swapChain</name></param>
- <param><type>VkBool32</type> <name>localDimmingEnable</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceCalibrateableTimeDomainsEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pTimeDomainCount</name></param>
- <param optional="true" len="pTimeDomainCount"><type>VkTimeDomainEXT</type>* <name>pTimeDomains</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetCalibratedTimestampsEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>timestampCount</name></param>
- <param len="timestampCount">const <type>VkCalibratedTimestampInfoEXT</type>* <name>pTimestampInfos</name></param>
- <param len="timestampCount"><type>uint64_t</type>* <name>pTimestamps</name></param>
- <param><type>uint64_t</type>* <name>pMaxDeviation</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkSetDebugUtilsObjectNameEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="pNameInfo->objectHandle">const <type>VkDebugUtilsObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkSetDebugUtilsObjectTagEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="pTagInfo->objectHandle">const <type>VkDebugUtilsObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueBeginDebugUtilsLabelEXT</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- <param>const <type>VkDebugUtilsLabelEXT</type>* <name>pLabelInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueEndDebugUtilsLabelEXT</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueInsertDebugUtilsLabelEXT</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- <param>const <type>VkDebugUtilsLabelEXT</type>* <name>pLabelInfo</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBeginDebugUtilsLabelEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkDebugUtilsLabelEXT</type>* <name>pLabelInfo</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdEndDebugUtilsLabelEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdInsertDebugUtilsLabelEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkDebugUtilsLabelEXT</type>* <name>pLabelInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateDebugUtilsMessengerEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkDebugUtilsMessengerCreateInfoEXT</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDebugUtilsMessengerEXT</type>* <name>pMessenger</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyDebugUtilsMessengerEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param optional="true" externsync="true"><type>VkDebugUtilsMessengerEXT</type> <name>messenger</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkSubmitDebugUtilsMessageEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param><type>VkDebugUtilsMessageSeverityFlagBitsEXT</type> <name>messageSeverity</name></param>
- <param><type>VkDebugUtilsMessageTypeFlagsEXT</type> <name>messageTypes</name></param>
- <param>const <type>VkDebugUtilsMessengerCallbackDataEXT</type>* <name>pCallbackData</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
- <proto><type>VkResult</type> <name>vkGetMemoryHostPointerPropertiesEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></param>
- <param optional="false">const <type>void</type>* <name>pHostPointer</name></param>
- <param><type>VkMemoryHostPointerPropertiesEXT</type>* <name>pMemoryHostPointerProperties</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWriteBufferMarkerAMD</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineStageFlagBits</type> <name>pipelineStage</name></param>
- <param><type>VkBuffer</type> <name>dstBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>dstOffset</name></param>
- <param><type>uint32_t</type> <name>marker</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateRenderPass2</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkRenderPassCreateInfo2</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkRenderPass</type>* <name>pRenderPass</name></param>
- </command>
- <command name="vkCreateRenderPass2KHR" alias="vkCreateRenderPass2"/>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdBeginRenderPass2</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkRenderPassBeginInfo</type>* <name>pRenderPassBegin</name></param>
- <param>const <type>VkSubpassBeginInfo</type>* <name>pSubpassBeginInfo</name></param>
- </command>
- <command name="vkCmdBeginRenderPass2KHR" alias="vkCmdBeginRenderPass2"/>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdNextSubpass2</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkSubpassBeginInfo</type>* <name>pSubpassBeginInfo</name></param>
- <param>const <type>VkSubpassEndInfo</type>* <name>pSubpassEndInfo</name></param>
- </command>
- <command name="vkCmdNextSubpass2KHR" alias="vkCmdNextSubpass2"/>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdEndRenderPass2</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkSubpassEndInfo</type>* <name>pSubpassEndInfo</name></param>
- </command>
- <command name="vkCmdEndRenderPass2KHR" alias="vkCmdEndRenderPass2"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkGetSemaphoreCounterValue</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkSemaphore</type> <name>semaphore</name></param>
- <param><type>uint64_t</type>* <name>pValue</name></param>
- </command>
- <command name="vkGetSemaphoreCounterValueKHR" alias="vkGetSemaphoreCounterValue"/>
- <command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkWaitSemaphores</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSemaphoreWaitInfo</type>* <name>pWaitInfo</name></param>
- <param><type>uint64_t</type> <name>timeout</name></param>
- </command>
- <command name="vkWaitSemaphoresKHR" alias="vkWaitSemaphores"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkSignalSemaphore</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkSemaphoreSignalInfo</type>* <name>pSignalInfo</name></param>
- </command>
- <command name="vkSignalSemaphoreKHR" alias="vkSignalSemaphore"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR">
- <proto><type>VkResult</type> <name>vkGetAndroidHardwareBufferPropertiesANDROID</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const struct <type>AHardwareBuffer</type>* <name>buffer</name></param>
- <param><type>VkAndroidHardwareBufferPropertiesANDROID</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetMemoryAndroidHardwareBufferANDROID</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkMemoryGetAndroidHardwareBufferInfoANDROID</type>* <name>pInfo</name></param>
- <param>struct <type>AHardwareBuffer</type>** <name>pBuffer</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawIndirectCount</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>VkBuffer</type> <name>countBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>countBufferOffset</name></param>
- <param><type>uint32_t</type> <name>maxDrawCount</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- </command>
- <command name="vkCmdDrawIndirectCountKHR" alias="vkCmdDrawIndirectCount"/>
- <command name="vkCmdDrawIndirectCountAMD" alias="vkCmdDrawIndirectCount"/>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawIndexedIndirectCount</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>VkBuffer</type> <name>countBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>countBufferOffset</name></param>
- <param><type>uint32_t</type> <name>maxDrawCount</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- </command>
- <command name="vkCmdDrawIndexedIndirectCountKHR" alias="vkCmdDrawIndexedIndirectCount"/>
- <command name="vkCmdDrawIndexedIndirectCountAMD" alias="vkCmdDrawIndexedIndirectCount"/>
- <command queues="graphics,compute,transfer" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetCheckpointNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param noautovalidity="true">const <type>void</type>* <name>pCheckpointMarker</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetQueueCheckpointDataNV</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pCheckpointDataCount</name></param>
- <param optional="true" len="pCheckpointDataCount"><type>VkCheckpointDataNV</type>* <name>pCheckpointData</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_MEMORY_MAP_FAILED">
- <proto><type>VkResult</type> <name>vkMapMemoryIntoAddressSpaceGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param optional="false,true"><type>uint64_t</type>* <name>pAddress</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkRegisterImageColorBufferGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>uint32_t</type> <name>colorBuffer</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkRegisterBufferColorBufferGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>uint32_t</type> <name>colorBuffer</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkUpdateDescriptorSetWithTemplateSizedGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkDescriptorSet</type> <name>descriptorSet</name></param>
- <param><type>VkDescriptorUpdateTemplate</type> <name>descriptorUpdateTemplate</name></param>
- <param><type>uint32_t</type> <name>imageInfoCount</name></param>
- <param><type>uint32_t</type> <name>bufferInfoCount</name></param>
- <param><type>uint32_t</type> <name>bufferViewCount</name></param>
- <param optional="true" len="imageInfoCount">const <type>uint32_t</type>* <name>pImageInfoEntryIndices</name></param>
- <param optional="true" len="bufferInfoCount">const <type>uint32_t</type>* <name>pBufferInfoEntryIndices</name></param>
- <param optional="true" len="bufferViewCount">const <type>uint32_t</type>* <name>pBufferViewEntryIndices</name></param>
- <param optional="true" len="imageInfoCount">const <type>VkDescriptorImageInfo</type>* <name>pImageInfos</name></param>
- <param optional="true" len="bufferInfoCount">const <type>VkDescriptorBufferInfo</type>* <name>pBufferInfos</name></param>
- <param optional="true" len="bufferViewCount">const <type>VkBufferView</type>* <name>pBufferViews</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkBeginCommandBufferAsyncGOOGLE</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCommandBufferBeginInfo</type>* <name>pBeginInfo</name></param>
- <implicitexternsyncparams>
- <param>the sname:VkCommandPool that pname:commandBuffer was allocated from</param>
- </implicitexternsyncparams>
- </command>
- <command>
- <proto><type>void</type> <name>vkEndCommandBufferAsyncGOOGLE</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <implicitexternsyncparams>
- <param>the sname:VkCommandPool that pname:commandBuffer was allocated from</param>
- </implicitexternsyncparams>
- </command>
- <command>
- <proto><type>void</type> <name>vkResetCommandBufferAsyncGOOGLE</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>VkCommandBufferResetFlags</type> <name>flags</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkCommandBufferHostSyncGOOGLE</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>needHostSync</name></param>
- <param><type>uint32_t</type> <name>sequenceNumber</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateImageWithRequirementsGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImageCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkImage</type>* <name>pImage</name></param>
- <param><type>VkMemoryRequirements</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateBufferWithRequirementsGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkBufferCreateInfo</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkBuffer</type>* <name>pBuffer</name></param>
- <param><type>VkMemoryRequirements</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetMemoryHostAddressInfoGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param optional="false,true"><type>uint64_t</type>* <name>pAddress</name></param>
- <param optional="false,true"><type>uint64_t</type>* <name>pSize</name></param>
- <param optional="false,true"><type>uint64_t</type>* <name>pHostmemId</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkFreeMemorySyncGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true" devicememoryhandle="1"><type>VkDeviceMemory</type> <name>memory</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueHostSyncGOOGLE</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param><type>uint32_t</type> <name>needHostSync</name></param>
- <param><type>uint32_t</type> <name>sequenceNumber</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueSubmitAsyncGOOGLE</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param optional="true"><type>uint32_t</type> <name>submitCount</name></param>
- <param len="submitCount" externsync="pSubmits[].pWaitSemaphores[],pSubmits[].pSignalSemaphores[]">const <type>VkSubmitInfo</type>* <name>pSubmits</name></param>
- <param optional="true" externsync="true"><type>VkFence</type> <name>fence</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueWaitIdleAsyncGOOGLE</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- </command>
- <command queues="sparse_binding">
- <proto><type>void</type> <name>vkQueueBindSparseAsyncGOOGLE</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param optional="true"><type>uint32_t</type> <name>bindInfoCount</name></param>
- <param len="bindInfoCount" externsync="pBindInfo[].pWaitSemaphores[],pBindInfo[].pSignalSemaphores[],pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image">const <type>VkBindSparseInfo</type>* <name>pBindInfo</name></param>
- <param optional="true" externsync="true"><type>VkFence</type> <name>fence</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetLinearImageLayoutGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkFormat</type> <name>format</name></param>
- <param><type>VkDeviceSize</type>* <name>pOffset</name></param>
- <param><type>VkDeviceSize</type>* <name>pRowPitchAlignment</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueFlushCommandsGOOGLE</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>dataSize</name></param>
- <param len="dataSize">const <type>void</type>* <name>pData</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetMTLDeviceMVK</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>void</type>** <name>pMTLDevice</name></param>
- </command>
- <command successcodes="VK_SUCCESS">
- <proto><type>VkResult</type> <name>vkSetMTLTextureMVK</name></proto>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>void</type>* <name>mtlTexture</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetMTLTextureMVK</name></proto>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>void</type>** <name>pMTLTexture</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetMTLBufferMVK</name></proto>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>void</type>** <name>pMTLBuffer</name></param>
- </command>
- <command successcodes="VK_SUCCESS">
- <proto><type>VkResult</type> <name>vkUseIOSurfaceMVK</name></proto>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>void</type>* <name>ioSurface</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetIOSurfaceMVK</name></proto>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>void</type>** <name>pIOSurface</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindTransformFeedbackBuffersEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstBinding</name></param>
- <param><type>uint32_t</type> <name>bindingCount</name></param>
- <param len="bindingCount">const <type>VkBuffer</type>* <name>pBuffers</name></param>
- <param len="bindingCount">const <type>VkDeviceSize</type>* <name>pOffsets</name></param>
- <param optional="true" len="bindingCount" noautovalidity="true">const <type>VkDeviceSize</type>* <name>pSizes</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBeginTransformFeedbackEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstCounterBuffer</name></param>
- <param optional="true"><type>uint32_t</type> <name>counterBufferCount</name></param>
- <param noautovalidity="true" len="counterBufferCount">const <type>VkBuffer</type>* <name>pCounterBuffers</name></param>
- <param optional="true" len="counterBufferCount">const <type>VkDeviceSize</type>* <name>pCounterBufferOffsets</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdEndTransformFeedbackEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstCounterBuffer</name></param>
- <param optional="true"><type>uint32_t</type> <name>counterBufferCount</name></param>
- <param noautovalidity="true" len="counterBufferCount">const <type>VkBuffer</type>* <name>pCounterBuffers</name></param>
- <param optional="true" len="counterBufferCount">const <type>VkDeviceSize</type>* <name>pCounterBufferOffsets</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBeginQueryIndexedEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>query</name></param>
- <param optional="true"><type>VkQueryControlFlags</type> <name>flags</name></param>
- <param><type>uint32_t</type> <name>index</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdEndQueryIndexedEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>query</name></param>
- <param><type>uint32_t</type> <name>index</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawIndirectByteCountEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>instanceCount</name></param>
- <param><type>uint32_t</type> <name>firstInstance</name></param>
- <param><type>VkBuffer</type> <name>counterBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>counterBufferOffset</name></param>
- <param><type>uint32_t</type> <name>counterOffset</name></param>
- <param><type>uint32_t</type> <name>vertexStride</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetExclusiveScissorNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstExclusiveScissor</name></param>
- <param><type>uint32_t</type> <name>exclusiveScissorCount</name></param>
- <param len="exclusiveScissorCount">const <type>VkRect2D</type>* <name>pExclusiveScissors</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindShadingRateImageNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>VkImageView</type> <name>imageView</name></param>
- <param><type>VkImageLayout</type> <name>imageLayout</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetViewportShadingRatePaletteNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstViewport</name></param>
- <param><type>uint32_t</type> <name>viewportCount</name></param>
- <param len="viewportCount">const <type>VkShadingRatePaletteNV</type>* <name>pShadingRatePalettes</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetCoarseSampleOrderNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkCoarseSampleOrderTypeNV</type> <name>sampleOrderType</name></param>
- <param optional="true"><type>uint32_t</type> <name>customSampleOrderCount</name></param>
- <param len="customSampleOrderCount">const <type>VkCoarseSampleOrderCustomNV</type>* <name>pCustomSampleOrders</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawMeshTasksNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>taskCount</name></param>
- <param><type>uint32_t</type> <name>firstTask</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawMeshTasksIndirectNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>uint32_t</type> <name>drawCount</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdDrawMeshTasksIndirectCountNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>buffer</name></param>
- <param><type>VkDeviceSize</type> <name>offset</name></param>
- <param><type>VkBuffer</type> <name>countBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>countBufferOffset</name></param>
- <param><type>uint32_t</type> <name>maxDrawCount</name></param>
- <param><type>uint32_t</type> <name>stride</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCompileDeferredNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkPipeline</type> <name>pipeline</name></param>
- <param><type>uint32_t</type> <name>shader</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateAccelerationStructureNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkAccelerationStructureCreateInfoNV</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkAccelerationStructureNV</type>* <name>pAccelerationStructure</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindInvocationMaskHUAWEI</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>VkImageView</type> <name>imageView</name></param>
- <param><type>VkImageLayout</type> <name>imageLayout</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyAccelerationStructureKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkAccelerationStructureKHR</type> <name>accelerationStructure</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyAccelerationStructureNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkAccelerationStructureNV</type> <name>accelerationStructure</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetAccelerationStructureMemoryRequirementsNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkAccelerationStructureMemoryRequirementsInfoNV</type>* <name>pInfo</name></param>
- <param><type>VkMemoryRequirements2KHR</type>* <name>pMemoryRequirements</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkBindAccelerationStructureMemoryNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>bindInfoCount</name></param>
- <param len="bindInfoCount">const <type>VkBindAccelerationStructureMemoryInfoNV</type>* <name>pBindInfos</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyAccelerationStructureNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkAccelerationStructureNV</type> <name>dst</name></param>
- <param><type>VkAccelerationStructureNV</type> <name>src</name></param>
- <param><type>VkCopyAccelerationStructureModeKHR</type> <name>mode</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyAccelerationStructureKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCopyAccelerationStructureInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_OPERATION_DEFERRED_KHR,VK_OPERATION_NOT_DEFERRED_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCopyAccelerationStructureKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkDeferredOperationKHR</type> <name>deferredOperation</name></param>
- <param>const <type>VkCopyAccelerationStructureInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyAccelerationStructureToMemoryKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCopyAccelerationStructureToMemoryInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_OPERATION_DEFERRED_KHR,VK_OPERATION_NOT_DEFERRED_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCopyAccelerationStructureToMemoryKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkDeferredOperationKHR</type> <name>deferredOperation</name></param>
- <param>const <type>VkCopyAccelerationStructureToMemoryInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyMemoryToAccelerationStructureKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCopyMemoryToAccelerationStructureInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_OPERATION_DEFERRED_KHR,VK_OPERATION_NOT_DEFERRED_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCopyMemoryToAccelerationStructureKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkDeferredOperationKHR</type> <name>deferredOperation</name></param>
- <param>const <type>VkCopyMemoryToAccelerationStructureInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWriteAccelerationStructuresPropertiesKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>accelerationStructureCount</name></param>
- <param len="accelerationStructureCount">const <type>VkAccelerationStructureKHR</type>* <name>pAccelerationStructures</name></param>
- <param><type>VkQueryType</type> <name>queryType</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>firstQuery</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWriteAccelerationStructuresPropertiesNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>accelerationStructureCount</name></param>
- <param len="accelerationStructureCount">const <type>VkAccelerationStructureNV</type>* <name>pAccelerationStructures</name></param>
- <param><type>VkQueryType</type> <name>queryType</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>firstQuery</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBuildAccelerationStructureNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkAccelerationStructureInfoNV</type>* <name>pInfo</name></param>
- <param optional="true"><type>VkBuffer</type> <name>instanceData</name></param>
- <param><type>VkDeviceSize</type> <name>instanceOffset</name></param>
- <param><type>VkBool32</type> <name>update</name></param>
- <param><type>VkAccelerationStructureNV</type> <name>dst</name></param>
- <param optional="true"><type>VkAccelerationStructureNV</type> <name>src</name></param>
- <param><type>VkBuffer</type> <name>scratch</name></param>
- <param><type>VkDeviceSize</type> <name>scratchOffset</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkWriteAccelerationStructuresPropertiesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>uint32_t</type> <name>accelerationStructureCount</name></param>
- <param len="accelerationStructureCount">const <type>VkAccelerationStructureKHR</type>* <name>pAccelerationStructures</name></param>
- <param><type>VkQueryType</type> <name>queryType</name></param>
- <param><type>size_t</type> <name>dataSize</name></param>
- <param len="dataSize"><type>void</type>* <name>pData</name></param>
- <param><type>size_t</type> <name>stride</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdTraceRaysKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pRaygenShaderBindingTable</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pMissShaderBindingTable</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pHitShaderBindingTable</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pCallableShaderBindingTable</name></param>
- <param><type>uint32_t</type> <name>width</name></param>
- <param><type>uint32_t</type> <name>height</name></param>
- <param><type>uint32_t</type> <name>depth</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdTraceRaysNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBuffer</type> <name>raygenShaderBindingTableBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>raygenShaderBindingOffset</name></param>
- <param optional="true"><type>VkBuffer</type> <name>missShaderBindingTableBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>missShaderBindingOffset</name></param>
- <param><type>VkDeviceSize</type> <name>missShaderBindingStride</name></param>
- <param optional="true"><type>VkBuffer</type> <name>hitShaderBindingTableBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>hitShaderBindingOffset</name></param>
- <param><type>VkDeviceSize</type> <name>hitShaderBindingStride</name></param>
- <param optional="true"><type>VkBuffer</type> <name>callableShaderBindingTableBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>callableShaderBindingOffset</name></param>
- <param><type>VkDeviceSize</type> <name>callableShaderBindingStride</name></param>
- <param><type>uint32_t</type> <name>width</name></param>
- <param><type>uint32_t</type> <name>height</name></param>
- <param><type>uint32_t</type> <name>depth</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetRayTracingShaderGroupHandlesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkPipeline</type> <name>pipeline</name></param>
- <param><type>uint32_t</type> <name>firstGroup</name></param>
- <param><type>uint32_t</type> <name>groupCount</name></param>
- <param><type>size_t</type> <name>dataSize</name></param>
- <param len="dataSize"><type>void</type>* <name>pData</name></param>
- </command>
- <command name="vkGetRayTracingShaderGroupHandlesNV" alias="vkGetRayTracingShaderGroupHandlesKHR"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetRayTracingCaptureReplayShaderGroupHandlesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkPipeline</type> <name>pipeline</name></param>
- <param><type>uint32_t</type> <name>firstGroup</name></param>
- <param><type>uint32_t</type> <name>groupCount</name></param>
- <param><type>size_t</type> <name>dataSize</name></param>
- <param len="dataSize"><type>void</type>* <name>pData</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetAccelerationStructureHandleNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkAccelerationStructureNV</type> <name>accelerationStructure</name></param>
- <param><type>size_t</type> <name>dataSize</name></param>
- <param len="dataSize"><type>void</type>* <name>pData</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_PIPELINE_COMPILE_REQUIRED_EXT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_SHADER_NV">
- <proto><type>VkResult</type> <name>vkCreateRayTracingPipelinesNV</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkPipelineCache</type> <name>pipelineCache</name></param>
- <param><type>uint32_t</type> <name>createInfoCount</name></param>
- <param len="createInfoCount">const <type>VkRayTracingPipelineCreateInfoNV</type>* <name>pCreateInfos</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param len="createInfoCount"><type>VkPipeline</type>* <name>pPipelines</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_OPERATION_DEFERRED_KHR,VK_OPERATION_NOT_DEFERRED_KHR,VK_PIPELINE_COMPILE_REQUIRED_EXT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS">
- <proto><type>VkResult</type> <name>vkCreateRayTracingPipelinesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkDeferredOperationKHR</type> <name>deferredOperation</name></param>
- <param optional="true"><type>VkPipelineCache</type> <name>pipelineCache</name></param>
- <param><type>uint32_t</type> <name>createInfoCount</name></param>
- <param len="createInfoCount">const <type>VkRayTracingPipelineCreateInfoKHR</type>* <name>pCreateInfos</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param len="createInfoCount"><type>VkPipeline</type>* <name>pPipelines</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceCooperativeMatrixPropertiesNV</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
- <param optional="true" len="pPropertyCount"><type>VkCooperativeMatrixPropertiesNV</type>* <name>pProperties</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdTraceRaysIndirectKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pRaygenShaderBindingTable</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pMissShaderBindingTable</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pHitShaderBindingTable</name></param>
- <param>const <type>VkStridedDeviceAddressRegionKHR</type>* <name>pCallableShaderBindingTable</name></param>
- <param><type>VkDeviceAddress</type> <name>indirectDeviceAddress</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetDeviceAccelerationStructureCompatibilityKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkAccelerationStructureVersionInfoKHR</type>* <name>pVersionInfo</name></param>
- <param><type>VkAccelerationStructureCompatibilityKHR</type>* <name>pCompatibility</name></param>
- </command>
- <command>
- <proto><type>VkDeviceSize</type> <name>vkGetRayTracingShaderGroupStackSizeKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkPipeline</type> <name>pipeline</name></param>
- <param><type>uint32_t</type> <name>group</name></param>
- <param><type>VkShaderGroupShaderKHR</type> <name>groupShader</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetRayTracingPipelineStackSizeKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>pipelineStackSize</name></param>
- </command>
- <command>
- <proto><type>uint32_t</type> <name>vkGetImageViewHandleNVX</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkImageViewHandleInfoNVX</type>* <name>pInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_UNKNOWN">
- <proto><type>VkResult</type> <name>vkGetImageViewAddressNVX</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkImageView</type> <name>imageView</name></param>
- <param><type>VkImageViewAddressPropertiesNVX</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSurfacePresentModes2EXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceSurfaceInfo2KHR</type>* <name>pSurfaceInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pPresentModeCount</name></param>
- <param optional="true" len="pPresentModeCount"><type>VkPresentModeKHR</type>* <name>pPresentModes</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkGetDeviceGroupSurfacePresentModes2EXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPhysicalDeviceSurfaceInfo2KHR</type>* <name>pSurfaceInfo</name></param>
- <param optional="false,true"><type>VkDeviceGroupPresentModeFlagsKHR</type>* <name>pModes</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkAcquireFullScreenExclusiveModeEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
- <proto><type>VkResult</type> <name>vkReleaseFullScreenExclusiveModeEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pCounterCount</name></param>
- <param optional="true" len="pCounterCount"><type>VkPerformanceCounterKHR</type>* <name>pCounters</name></param>
- <param optional="true" len="pCounterCount"><type>VkPerformanceCounterDescriptionKHR</type>* <name>pCounterDescriptions</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkQueryPoolPerformanceCreateInfoKHR</type>* <name>pPerformanceQueryCreateInfo</name></param>
- <param><type>uint32_t</type>* <name>pNumPasses</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_TIMEOUT">
- <proto><type>VkResult</type> <name>vkAcquireProfilingLockKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkAcquireProfilingLockInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkReleaseProfilingLockKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetImageDrmFormatModifierPropertiesEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- <param><type>VkImageDrmFormatModifierPropertiesEXT</type>* <name>pProperties</name></param>
- </command>
- <command>
- <proto><type>uint64_t</type> <name>vkGetBufferOpaqueCaptureAddress</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkBufferDeviceAddressInfo</type>* <name>pInfo</name></param>
- </command>
- <command name="vkGetBufferOpaqueCaptureAddressKHR" alias="vkGetBufferOpaqueCaptureAddress"/>
- <command>
- <proto><type>VkDeviceAddress</type> <name>vkGetBufferDeviceAddress</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkBufferDeviceAddressInfo</type>* <name>pInfo</name></param>
- </command>
- <command name="vkGetBufferDeviceAddressKHR" alias="vkGetBufferDeviceAddress"/>
- <command name="vkGetBufferDeviceAddressEXT" alias="vkGetBufferDeviceAddress"/>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateHeadlessSurfaceEXT</name></proto>
- <param><type>VkInstance</type> <name>instance</name></param>
- <param>const <type>VkHeadlessSurfaceCreateInfoEXT</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pCombinationCount</name></param>
- <param optional="true" len="pCombinationCount"><type>VkFramebufferMixedSamplesCombinationNV</type>* <name>pCombinations</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkInitializePerformanceApiINTEL</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkInitializePerformanceApiInfoINTEL</type>* <name>pInitializeInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkUninitializePerformanceApiINTEL</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- </command>
- <command queues="graphics,compute,transfer" renderpass="both" cmdbufferlevel="primary,secondary" successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCmdSetPerformanceMarkerINTEL</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkPerformanceMarkerInfoINTEL</type>* <name>pMarkerInfo</name></param>
- </command>
- <command queues="graphics,compute,transfer" renderpass="both" cmdbufferlevel="primary,secondary" successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCmdSetPerformanceStreamMarkerINTEL</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkPerformanceStreamMarkerInfoINTEL</type>* <name>pMarkerInfo</name></param>
- </command>
- <command queues="graphics,compute,transfer" renderpass="both" cmdbufferlevel="primary,secondary" successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCmdSetPerformanceOverrideINTEL</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkPerformanceOverrideInfoINTEL</type>* <name>pOverrideInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkAcquirePerformanceConfigurationINTEL</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPerformanceConfigurationAcquireInfoINTEL</type>* <name>pAcquireInfo</name></param>
- <param><type>VkPerformanceConfigurationINTEL</type>* <name>pConfiguration</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkReleasePerformanceConfigurationINTEL</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkPerformanceConfigurationINTEL</type> <name>configuration</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkQueueSetPerformanceConfigurationINTEL</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- <param><type>VkPerformanceConfigurationINTEL</type> <name>configuration</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPerformanceParameterINTEL</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkPerformanceParameterTypeINTEL</type> <name>parameter</name></param>
- <param><type>VkPerformanceValueINTEL</type>* <name>pValue</name></param>
- </command>
- <command>
- <proto><type>uint64_t</type> <name>vkGetDeviceMemoryOpaqueCaptureAddress</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkDeviceMemoryOpaqueCaptureAddressInfo</type>* <name>pInfo</name></param>
- </command>
- <command name="vkGetDeviceMemoryOpaqueCaptureAddressKHR" alias="vkGetDeviceMemoryOpaqueCaptureAddress"/>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPipelineExecutablePropertiesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPipelineInfoKHR</type>* <name>pPipelineInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pExecutableCount</name></param>
- <param optional="true" len="pExecutableCount"><type>VkPipelineExecutablePropertiesKHR</type>* <name>pProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPipelineExecutableStatisticsKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPipelineExecutableInfoKHR</type>* <name>pExecutableInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pStatisticCount</name></param>
- <param optional="true" len="pStatisticCount"><type>VkPipelineExecutableStatisticKHR</type>* <name>pStatistics</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPipelineExecutableInternalRepresentationsKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPipelineExecutableInfoKHR</type>* <name>pExecutableInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pInternalRepresentationCount</name></param>
- <param optional="true" len="pInternalRepresentationCount"><type>VkPipelineExecutableInternalRepresentationKHR</type>* <name>pInternalRepresentations</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetLineStippleEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>lineStippleFactor</name></param>
- <param><type>uint16_t</type> <name>lineStipplePattern</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceToolPropertiesEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pToolCount</name></param>
- <param optional="true" len="pToolCount"><type>VkPhysicalDeviceToolPropertiesEXT</type>* <name>pToolProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR">
- <proto><type>VkResult</type> <name>vkCreateAccelerationStructureKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkAccelerationStructureCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkAccelerationStructureKHR</type>* <name>pAccelerationStructure</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBuildAccelerationStructuresKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>infoCount</name></param>
- <param len="infoCount">const <type>VkAccelerationStructureBuildGeometryInfoKHR</type>* <name>pInfos</name></param>
- <param len="infoCount">const <type>VkAccelerationStructureBuildRangeInfoKHR</type>* const* <name>ppBuildRangeInfos</name></param>
- </command>
- <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBuildAccelerationStructuresIndirectKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>infoCount</name></param>
- <param len="infoCount">const <type>VkAccelerationStructureBuildGeometryInfoKHR</type>* <name>pInfos</name></param>
- <param len="infoCount">const <type>VkDeviceAddress</type>* <name>pIndirectDeviceAddresses</name></param>
- <param len="infoCount">const <type>uint32_t</type>* <name>pIndirectStrides</name></param>
- <param len="infoCount">const <type>uint32_t</type>* const* <name>ppMaxPrimitiveCounts</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_OPERATION_DEFERRED_KHR,VK_OPERATION_NOT_DEFERRED_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkBuildAccelerationStructuresKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true"><type>VkDeferredOperationKHR</type> <name>deferredOperation</name></param>
- <param><type>uint32_t</type> <name>infoCount</name></param>
- <param len="infoCount">const <type>VkAccelerationStructureBuildGeometryInfoKHR</type>* <name>pInfos</name></param>
- <param len="infoCount">const <type>VkAccelerationStructureBuildRangeInfoKHR</type>* const* <name>ppBuildRangeInfos</name></param>
- </command>
- <command>
- <proto><type>VkDeviceAddress</type> <name>vkGetAccelerationStructureDeviceAddressKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkAccelerationStructureDeviceAddressInfoKHR</type>* <name>pInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCreateDeferredOperationKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkDeferredOperationKHR</type>* <name>pDeferredOperation</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyDeferredOperationKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkDeferredOperationKHR</type> <name>operation</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>uint32_t</type> <name>vkGetDeferredOperationMaxConcurrencyKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkDeferredOperationKHR</type> <name>operation</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_NOT_READY">
- <proto><type>VkResult</type> <name>vkGetDeferredOperationResultKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkDeferredOperationKHR</type> <name>operation</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_THREAD_DONE_KHR,VK_THREAD_IDLE_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
- <proto><type>VkResult</type> <name>vkDeferredOperationJoinKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkDeferredOperationKHR</type> <name>operation</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetCullModeEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>VkCullModeFlags</type> <name>cullMode</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetFrontFaceEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkFrontFace</type> <name>frontFace</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetPrimitiveTopologyEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPrimitiveTopology</type> <name>primitiveTopology</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetViewportWithCountEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>viewportCount</name></param>
- <param len="viewportCount">const <type>VkViewport</type>* <name>pViewports</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetScissorWithCountEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>scissorCount</name></param>
- <param len="scissorCount">const <type>VkRect2D</type>* <name>pScissors</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBindVertexBuffers2EXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>firstBinding</name></param>
- <param><type>uint32_t</type> <name>bindingCount</name></param>
- <param len="bindingCount" optional="false,true">const <type>VkBuffer</type>* <name>pBuffers</name></param>
- <param len="bindingCount">const <type>VkDeviceSize</type>* <name>pOffsets</name></param>
- <param optional="true" len="bindingCount">const <type>VkDeviceSize</type>* <name>pSizes</name></param>
- <param optional="true" len="bindingCount">const <type>VkDeviceSize</type>* <name>pStrides</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDepthTestEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>depthTestEnable</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDepthWriteEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>depthWriteEnable</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDepthCompareOpEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkCompareOp</type> <name>depthCompareOp</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDepthBoundsTestEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>depthBoundsTestEnable</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetStencilTestEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>stencilTestEnable</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetStencilOpEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkStencilFaceFlags</type> <name>faceMask</name></param>
- <param><type>VkStencilOp</type> <name>failOp</name></param>
- <param><type>VkStencilOp</type> <name>passOp</name></param>
- <param><type>VkStencilOp</type> <name>depthFailOp</name></param>
- <param><type>VkCompareOp</type> <name>compareOp</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetPatchControlPointsEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>patchControlPoints</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetRasterizerDiscardEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>rasterizerDiscardEnable</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetDepthBiasEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>depthBiasEnable</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetLogicOpEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkLogicOp</type> <name>logicOp</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetPrimitiveRestartEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkBool32</type> <name>primitiveRestartEnable</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkCreatePrivateDataSlotEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkPrivateDataSlotCreateInfoEXT</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkPrivateDataSlotEXT</type>* <name>pPrivateDataSlot</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyPrivateDataSlotEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param optional="true" externsync="true"><type>VkPrivateDataSlotEXT</type> <name>privateDataSlot</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkSetPrivateDataEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkObjectType</type> <name>objectType</name></param>
- <param objecttype="objectType"><type>uint64_t</type> <name>objectHandle</name></param>
- <param><type>VkPrivateDataSlotEXT</type> <name>privateDataSlot</name></param>
- <param><type>uint64_t</type> <name>data</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetPrivateDataEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkObjectType</type> <name>objectType</name></param>
- <param objecttype="objectType"><type>uint64_t</type> <name>objectHandle</name></param>
- <param><type>VkPrivateDataSlotEXT</type> <name>privateDataSlot</name></param>
- <param><type>uint64_t</type>* <name>pData</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyBuffer2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCopyBufferInfo2KHR</type>* <name>pCopyBufferInfo</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyImage2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCopyImageInfo2KHR</type>* <name>pCopyImageInfo</name></param>
- </command>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBlitImage2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkBlitImageInfo2KHR</type>* <name>pBlitImageInfo</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyBufferToImage2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCopyBufferToImageInfo2KHR</type>* <name>pCopyBufferToImageInfo</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCopyImageToBuffer2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCopyImageToBufferInfo2KHR</type>* <name>pCopyImageToBufferInfo</name></param>
- </command>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdResolveImage2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkResolveImageInfo2KHR</type>* <name>pResolveImageInfo</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetFragmentShadingRateKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkExtent2D</type>* <name>pFragmentSize</name></param>
- <param>const <type>VkFragmentShadingRateCombinerOpKHR</type> <name>combinerOps</name>[2]</param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceFragmentShadingRatesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pFragmentShadingRateCount</name></param>
- <param optional="true" len="pFragmentShadingRateCount"><type>VkPhysicalDeviceFragmentShadingRateKHR</type>* <name>pFragmentShadingRates</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetFragmentShadingRateEnumNV</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkFragmentShadingRateNV</type> <name>shadingRate</name></param>
- <param>const <type>VkFragmentShadingRateCombinerOpKHR</type> <name>combinerOps</name>[2]</param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetAccelerationStructureBuildSizesKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkAccelerationStructureBuildTypeKHR</type> <name>buildType</name></param>
- <param>const <type>VkAccelerationStructureBuildGeometryInfoKHR</type>* <name>pBuildInfo</name></param>
- <param optional="true" len="pBuildInfo->geometryCount">const <type>uint32_t</type>* <name>pMaxPrimitiveCounts</name></param>
- <param><type>VkAccelerationStructureBuildSizesInfoKHR</type>* <name>pSizeInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueCommitDescriptorSetUpdatesGOOGLE</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param externsync="true"><type>uint32_t</type> <name>descriptorPoolCount</name></param>
- <param len="descriptorPoolCount" externsync="true">const <type>VkDescriptorPool</type>* <name>pDescriptorPools</name></param>
- <param externsync="true"><type>uint32_t</type> <name>descriptorSetCount</name></param>
- <param len="descriptorSetCount" externsync="true">const <type>VkDescriptorSetLayout</type>* <name>pSetLayouts</name></param>
- <param len="descriptorSetCount" externsync="true">const <type>uint64_t</type>* <name>pDescriptorSetPoolIds</name></param>
- <param len="descriptorSetCount" externsync="true">const <type>uint32_t</type>* <name>pDescriptorSetWhichPool</name></param>
- <param len="descriptorSetCount" externsync="true">const <type>uint32_t</type>* <name>pDescriptorSetPendingAllocation</name></param>
- <param len="descriptorSetCount" externsync="true">const <type>uint32_t</type>* <name>pDescriptorWriteStartingIndices</name></param>
- <param externsync="true"><type>uint32_t</type> <name>pendingDescriptorWriteCount</name></param>
- <param len="pendingDescriptorWriteCount" externsync="true">const <type>VkWriteDescriptorSet</type>* <name>pPendingDescriptorWrites</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkCollectDescriptorPoolIdsGOOGLE</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></param>
- <param optiona="false,true"><type>uint32_t</type>* <name>pPoolIdCount</name></param>
- <param optional="true" len="pPoolIdCount"><type>uint64_t</type>* <name>pPoolIds</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkQueueSignalReleaseImageANDROIDAsyncGOOGLE</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- <param optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></param>
- <param noautovalidity="true" len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></param>
- <param><type>VkImage</type> <name>image</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetVertexInputEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param optional="true"><type>uint32_t</type> <name>vertexBindingDescriptionCount</name></param>
- <param len="vertexBindingDescriptionCount">const <type>VkVertexInputBindingDescription2EXT</type>* <name>pVertexBindingDescriptions</name></param>
- <param optional="true"><type>uint32_t</type> <name>vertexAttributeDescriptionCount</name></param>
- <param len="vertexAttributeDescriptionCount">const <type>VkVertexInputAttributeDescription2EXT</type>* <name>pVertexAttributeDescriptions</name></param>
- </command>
- <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetColorWriteEnableEXT</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>attachmentCount</name></param>
- <param len="attachmentCount">const <type>VkBool32</type>* <name>pColorWriteEnables</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdSetEvent2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkEvent</type> <name>event</name></param>
- <param>const <type>VkDependencyInfoKHR</type>* <name>pDependencyInfo</name></param>
- </command>
- <command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdResetEvent2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkEvent</type> <name>event</name></param>
- <param><type>VkPipelineStageFlags2KHR</type> <name>stageMask</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWaitEvents2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>uint32_t</type> <name>eventCount</name></param>
- <param len="eventCount">const <type>VkEvent</type>* <name>pEvents</name></param>
- <param len="eventCount">const <type>VkDependencyInfoKHR</type>* <name>pDependencyInfos</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdPipelineBarrier2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkDependencyInfoKHR</type>* <name>pDependencyInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkQueueSubmit2KHR</name></proto>
- <param externsync="true"><type>VkQueue</type> <name>queue</name></param>
- <param optional="true"><type>uint32_t</type> <name>submitCount</name></param>
- <param len="submitCount">const <type>VkSubmitInfo2KHR</type>* <name>pSubmits</name></param>
- <param optional="true" externsync="true"><type>VkFence</type> <name>fence</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWriteTimestamp2KHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineStageFlags2KHR</type> <name>stage</name></param>
- <param><type>VkQueryPool</type> <name>queryPool</name></param>
- <param><type>uint32_t</type> <name>query</name></param>
- </command>
- <command queues="transfer,graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdWriteBufferMarker2AMD</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param><type>VkPipelineStageFlags2KHR</type> <name>stage</name></param>
- <param><type>VkBuffer</type> <name>dstBuffer</name></param>
- <param><type>VkDeviceSize</type> <name>dstOffset</name></param>
- <param><type>uint32_t</type> <name>marker</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkGetQueueCheckpointData2NV</name></proto>
- <param><type>VkQueue</type> <name>queue</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pCheckpointDataCount</name></param>
- <param optional="true" len="pCheckpointDataCount"><type>VkCheckpointData2NV</type>* <name>pCheckpointData</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_EXTENSION_NOT_PRESENT,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_FEATURE_NOT_PRESENT,VK_ERROR_FORMAT_NOT_SUPPORTED">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceVideoCapabilitiesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkVideoProfileKHR</type>* <name>pVideoProfile</name></param>
- <param><type>VkVideoCapabilitiesKHR</type>* <name>pCapabilities</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_EXTENSION_NOT_PRESENT,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_FORMAT_NOT_SUPPORTED">
- <proto><type>VkResult</type> <name>vkGetPhysicalDeviceVideoFormatPropertiesKHR</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param>const <type>VkPhysicalDeviceVideoFormatInfoKHR</type>* <name>pVideoFormatInfo</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pVideoFormatPropertyCount</name></param>
- <param optional="true" len="pVideoFormatPropertyCount"><type>VkVideoFormatPropertiesKHR</type>* <name>pVideoFormatProperties</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_INCOMPATIBLE_DRIVER,VK_ERROR_FEATURE_NOT_PRESENT">
- <proto><type>VkResult</type> <name>vkCreateVideoSessionKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkVideoSessionCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkVideoSessionKHR</type>* <name>pVideoSession</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyVideoSessionKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkVideoSessionKHR</type> <name>videoSession</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_TOO_MANY_OBJECTS">
- <proto><type>VkResult</type> <name>vkCreateVideoSessionParametersKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkVideoSessionParametersCreateInfoKHR</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkVideoSessionParametersKHR</type>* <name>pVideoSessionParameters</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_TOO_MANY_OBJECTS">
- <proto><type>VkResult</type> <name>vkUpdateVideoSessionParametersKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkVideoSessionParametersKHR</type> <name>videoSessionParameters</name></param>
- <param>const <type>VkVideoSessionParametersUpdateInfoKHR</type>* <name>pUpdateInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyVideoSessionParametersKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkVideoSessionParametersKHR</type> <name>videoSessionParameters</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkGetVideoSessionMemoryRequirementsKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkVideoSessionKHR</type> <name>videoSession</name></param>
- <param optional="false,true"><type>uint32_t</type>* <name>pVideoSessionMemoryRequirementsCount</name></param>
- <param optional="true" len="pVideoSessionMemoryRequirementsCount"><type>VkVideoGetMemoryPropertiesKHR</type>* <name>pVideoSessionMemoryRequirements</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkBindVideoSessionMemoryKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkVideoSessionKHR</type> <name>videoSession</name></param>
- <param><type>uint32_t</type> <name>videoSessionBindMemoryCount</name></param>
- <param len="videoSessionBindMemoryCount">const <type>VkVideoBindMemoryKHR</type>* <name>pVideoSessionBindMemories</name></param>
- </command>
- <command queues="decode" renderpass="outside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdDecodeVideoKHR</name></proto>
- <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkVideoDecodeInfoKHR</type>* <name>pFrameInfo</name></param>
- </command>
- <command queues="decode,encode" renderpass="outside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdBeginVideoCodingKHR</name></proto>
- <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkVideoBeginCodingInfoKHR</type>* <name>pBeginInfo</name></param>
- </command>
- <command queues="decode,encode" renderpass="outside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdControlVideoCodingKHR</name></proto>
- <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkVideoCodingControlInfoKHR</type>* <name>pCodingControlInfo</name></param>
- </command>
- <command queues="decode,encode" renderpass="outside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdEndVideoCodingKHR</name></proto>
- <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkVideoEndCodingInfoKHR</type>* <name>pEndCodingInfo</name></param>
- </command>
- <command queues="encode" renderpass="outside" cmdbufferlevel="primary">
- <proto><type>void</type> <name>vkCmdEncodeVideoKHR</name></proto>
- <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkVideoEncodeInfoKHR</type>* <name>pEncodeInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkCreateCuModuleNVX</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkCuModuleCreateInfoNVX</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkCuModuleNVX</type>* <name>pModule</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkCreateCuFunctionNVX</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkCuFunctionCreateInfoNVX</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkCuFunctionNVX</type>* <name>pFunction</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyCuModuleNVX</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkCuModuleNVX</type> <name>module</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyCuFunctionNVX</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkCuFunctionNVX</type> <name>function</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdCuLaunchKernelNVX</name></proto>
- <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkCuLaunchInfoNVX</type>* <name>pLaunchInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkSetDeviceMemoryPriorityEXT</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkDeviceMemory</type> <name>memory</name></param>
- <param><type>float</type> <name>priority</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkAcquireDrmDisplayEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>int32_t</type> <name>drmFd</name></param>
- <param><type>VkDisplayKHR</type> <name>display</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_OUT_OF_HOST_MEMORY">
- <proto><type>VkResult</type> <name>vkGetDrmDisplayEXT</name></proto>
- <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
- <param><type>int32_t</type> <name>drmFd</name></param>
- <param><type>uint32_t</type> <name>connectorId</name></param>
- <param><type>VkDisplayKHR</type>* <name>display</name></param>
- </command>
- <command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkWaitForPresentKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param><type>uint64_t</type> <name>presentId</name></param>
- <param><type>uint64_t</type> <name>timeout</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkCreateBufferCollectionFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param>const <type>VkBufferCollectionCreateInfoFUCHSIA</type>* <name>pCreateInfo</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- <param><type>VkBufferCollectionFUCHSIA</type>* <name>pCollection</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_FORMAT_NOT_SUPPORTED">
- <proto><type>VkResult</type> <name>vkSetBufferCollectionBufferConstraintsFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
- <param>const <type>VkBufferConstraintsInfoFUCHSIA</type>* <name>pBufferConstraintsInfo</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_FORMAT_NOT_SUPPORTED">
- <proto><type>VkResult</type> <name>vkSetBufferCollectionImageConstraintsFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
- <param>const <type>VkImageConstraintsInfoFUCHSIA</type>* <name>pImageConstraintsInfo</name></param>
- </command>
- <command>
- <proto><type>void</type> <name>vkDestroyBufferCollectionFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
- <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
- </command>
- <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
- <proto><type>VkResult</type> <name>vkGetBufferCollectionPropertiesFUCHSIA</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param><type>VkBufferCollectionFUCHSIA</type> <name>collection</name></param>
- <param><type>VkBufferCollectionPropertiesFUCHSIA</type>* <name>pProperties</name></param>
- </command>
- <command queues="graphics" renderpass="outside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdBeginRenderingKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- <param>const <type>VkRenderingInfoKHR</type>* <name>pRenderingInfo</name></param>
- </command>
- <command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary">
- <proto><type>void</type> <name>vkCmdEndRenderingKHR</name></proto>
- <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
- </command>
- </commands>
-
- <feature api="vulkan" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
- <require comment="Header boilerplate">
- <type name="vk_platform"/>
- <type name="VK_DEFINE_HANDLE"/>
- <type name="VK_USE_64_BIT_PTR_DEFINES"/>
- <type name="VK_DEFINE_NON_DISPATCHABLE_HANDLE"/>
- <type name="VK_NULL_HANDLE"/>
- </require>
- <require comment="Fundamental types used by many commands and structures">
- <type name="VkBool32"/>
- <type name="VkDeviceAddress"/>
- <type name="VkDeviceSize"/>
- <type name="VkExtent2D"/>
- <type name="VkExtent3D"/>
- <type name="VkFlags"/>
- <type name="VkOffset2D"/>
- <type name="VkOffset3D"/>
- <type name="VkRect2D"/>
- <type name="VkResult"/>
- <type name="VkStructureType"/>
- </require>
- <require comment="These types are part of the API, though not directly used in API commands or data structures">
- <type name="VkBaseInStructure"/>
- <type name="VkBaseOutStructure"/>
- <type name="VkBufferMemoryBarrier"/>
- <type name="VkDispatchIndirectCommand"/>
- <type name="VkDrawIndexedIndirectCommand"/>
- <type name="VkDrawIndirectCommand"/>
- <type name="VkImageMemoryBarrier"/>
- <type name="VkMemoryBarrier"/>
- <type name="VkObjectType"/>
- <type name="VkPipelineCacheHeaderVersionOne"/>
- <type name="VkVendorId"/>
- </require>
- <require comment="API version macros">
- <type name="VK_API_VERSION"/>
- <type name="VK_API_VERSION_1_0"/>
- <type name="VK_HEADER_VERSION"/>
- <type name="VK_HEADER_VERSION_COMPLETE"/>
- <type name="VK_MAKE_VERSION"/>
- <type name="VK_VERSION_MAJOR"/>
- <type name="VK_VERSION_MINOR"/>
- <type name="VK_VERSION_PATCH"/>
- <type name="VK_MAKE_API_VERSION"/>
- <type name="VK_API_VERSION_VARIANT"/>
- <type name="VK_API_VERSION_MAJOR"/>
- <type name="VK_API_VERSION_MINOR"/>
- <type name="VK_API_VERSION_PATCH"/>
- </require>
- <require comment="API constants">
- <enum name="VK_ATTACHMENT_UNUSED"/>
- <enum name="VK_FALSE"/>
- <enum name="VK_LOD_CLAMP_NONE"/>
- <enum name="VK_QUEUE_FAMILY_IGNORED"/>
- <enum name="VK_REMAINING_ARRAY_LAYERS"/>
- <enum name="VK_REMAINING_MIP_LEVELS"/>
- <enum name="VK_SUBPASS_EXTERNAL"/>
- <enum name="VK_TRUE"/>
- <enum name="VK_WHOLE_SIZE"/>
- <type name="VkPipelineCacheHeaderVersion"/>
- </require>
- <require comment="Device initialization">
- <type name="PFN_vkAllocationFunction"/>
- <type name="PFN_vkFreeFunction"/>
- <type name="PFN_vkInternalAllocationNotification"/>
- <type name="PFN_vkInternalFreeNotification"/>
- <type name="PFN_vkReallocationFunction"/>
- <type name="PFN_vkVoidFunction"/>
- <type name="VkAllocationCallbacks"/>
- <type name="VkApplicationInfo"/>
- <type name="VkFormat"/>
- <type name="VkFormatFeatureFlagBits"/>
- <type name="VkFormatFeatureFlags"/>
- <type name="VkFormatProperties"/>
- <type name="VkImageCreateFlagBits"/>
- <type name="VkImageCreateFlags"/>
- <type name="VkImageFormatProperties"/>
- <type name="VkImageTiling"/>
- <type name="VkImageType"/>
- <type name="VkImageUsageFlagBits"/>
- <type name="VkImageUsageFlags"/>
- <type name="VkInstance"/>
- <type name="VkInstanceCreateFlags" comment="Will add VkInstanceCreateFlagBits when bits are defined in the future"/>
- <type name="VkInstanceCreateInfo"/>
- <type name="VkInternalAllocationType"/>
- <type name="VkMemoryHeap"/>
- <type name="VkMemoryHeapFlagBits"/>
- <type name="VkMemoryHeapFlags"/>
- <type name="VkMemoryPropertyFlagBits"/>
- <type name="VkMemoryPropertyFlags"/>
- <type name="VkMemoryType"/>
- <type name="VkPhysicalDevice"/>
- <type name="VkPhysicalDeviceFeatures"/>
- <type name="VkPhysicalDeviceLimits"/>
- <type name="VkPhysicalDeviceMemoryProperties"/>
- <type name="VkPhysicalDeviceProperties"/>
- <type name="VkPhysicalDeviceSparseProperties"/>
- <type name="VkPhysicalDeviceType"/>
- <type name="VkQueueFamilyProperties"/>
- <type name="VkQueueFlagBits"/>
- <type name="VkQueueFlags"/>
- <type name="VkSampleCountFlagBits"/>
- <type name="VkSampleCountFlags"/>
- <type name="VkSystemAllocationScope"/>
- <command name="vkCreateInstance"/>
- <command name="vkDestroyInstance"/>
- <command name="vkEnumeratePhysicalDevices"/>
- <command name="vkGetPhysicalDeviceFeatures"/>
- <command name="vkGetPhysicalDeviceFormatProperties"/>
- <command name="vkGetPhysicalDeviceImageFormatProperties"/>
- <command name="vkGetPhysicalDeviceProperties"/>
- <command name="vkGetPhysicalDeviceQueueFamilyProperties"/>
- <command name="vkGetPhysicalDeviceMemoryProperties"/>
- <command name="vkGetInstanceProcAddr"/>
- <command name="vkGetDeviceProcAddr"/>
- </require>
- <require comment="Device commands">
- <type name="VkDevice"/>
- <type name="VkDeviceCreateFlags" comment="Will add VkDeviceCreateFlagBits when bits are defined in the future"/>
- <type name="VkDeviceCreateInfo"/>
- <type name="VkDeviceQueueCreateFlags" comment="VkDeviceQueueCreateFlagBits was added later"/>
- <type name="VkDeviceQueueCreateInfo"/>
- <command name="vkCreateDevice"/>
- <command name="vkDestroyDevice"/>
- </require>
- <require comment="Extension discovery commands">
- <type name="VkExtensionProperties"/>
- <command name="vkEnumerateInstanceExtensionProperties"/>
- <command name="vkEnumerateDeviceExtensionProperties"/>
- </require>
- <require comment="Layer discovery commands">
- <type name="VkLayerProperties"/>
- <command name="vkEnumerateInstanceLayerProperties"/>
- <command name="vkEnumerateDeviceLayerProperties"/>
- </require>
- <require comment="Queue commands">
- <type name="VkPipelineStageFlagBits"/>
- <type name="VkPipelineStageFlags"/>
- <type name="VkQueue"/>
- <type name="VkSubmitInfo"/>
- <command name="vkGetDeviceQueue"/>
- <command name="vkQueueSubmit"/>
- <command name="vkQueueWaitIdle"/>
- <command name="vkDeviceWaitIdle"/>
- </require>
- <require comment="Memory commands">
- <type name="VkMappedMemoryRange"/>
- <type name="VkMemoryAllocateInfo"/>
- <type name="VkMemoryMapFlags"/>
- <command name="vkAllocateMemory"/>
- <command name="vkFreeMemory"/>
- <command name="vkMapMemory"/>
- <command name="vkUnmapMemory"/>
- <command name="vkFlushMappedMemoryRanges"/>
- <command name="vkInvalidateMappedMemoryRanges"/>
- <command name="vkGetDeviceMemoryCommitment"/>
- </require>
- <require comment="Memory management API commands">
- <type name="VkDeviceMemory"/>
- <type name="VkMemoryRequirements"/>
- <command name="vkBindBufferMemory"/>
- <command name="vkBindImageMemory"/>
- <command name="vkGetBufferMemoryRequirements"/>
- <command name="vkGetImageMemoryRequirements"/>
- </require>
- <require comment="Sparse resource memory management API commands">
- <type name="VkBindSparseInfo"/>
- <type name="VkImageAspectFlagBits"/>
- <type name="VkImageAspectFlags"/>
- <type name="VkImageSubresource"/>
- <type name="VkSparseBufferMemoryBindInfo"/>
- <type name="VkSparseImageFormatFlagBits"/>
- <type name="VkSparseImageFormatFlags"/>
- <type name="VkSparseImageFormatProperties"/>
- <type name="VkSparseImageMemoryBind"/>
- <type name="VkSparseImageMemoryBindInfo"/>
- <type name="VkSparseImageMemoryRequirements"/>
- <type name="VkSparseImageOpaqueMemoryBindInfo"/>
- <type name="VkSparseMemoryBind"/>
- <type name="VkSparseMemoryBindFlagBits"/>
- <type name="VkSparseMemoryBindFlags"/>
- <command name="vkGetImageSparseMemoryRequirements"/>
- <command name="vkGetPhysicalDeviceSparseImageFormatProperties"/>
- <command name="vkQueueBindSparse"/>
- </require>
- <require comment="Fence commands">
- <type name="VkFence"/>
- <type name="VkFenceCreateFlagBits"/>
- <type name="VkFenceCreateFlags"/>
- <type name="VkFenceCreateInfo"/>
- <command name="vkCreateFence"/>
- <command name="vkDestroyFence"/>
- <command name="vkResetFences"/>
- <command name="vkGetFenceStatus"/>
- <command name="vkWaitForFences"/>
- </require>
- <require comment="Queue semaphore commands">
- <type name="VkSemaphore"/>
- <type name="VkSemaphoreCreateFlags" comment="Will add VkSemaphoreCreateFlagBits when bits are defined in the future"/>
- <type name="VkSemaphoreCreateInfo"/>
- <command name="vkCreateSemaphore"/>
- <command name="vkDestroySemaphore"/>
- </require>
- <require comment="Event commands">
- <type name="VkEvent"/>
- <type name="VkEventCreateFlags"/>
- <type name="VkEventCreateFlagBits"/>
- <type name="VkEventCreateInfo"/>
- <command name="vkCreateEvent"/>
- <command name="vkDestroyEvent"/>
- <command name="vkGetEventStatus"/>
- <command name="vkSetEvent"/>
- <command name="vkResetEvent"/>
- </require>
- <require comment="Query commands">
- <type name="VkQueryPipelineStatisticFlagBits"/>
- <type name="VkQueryPipelineStatisticFlags"/>
- <type name="VkQueryPool"/>
- <type name="VkQueryPoolCreateFlags" comment="Will add VkQueryPoolCreateFlagBits when bits are defined in the future"/>
- <type name="VkQueryPoolCreateInfo"/>
- <type name="VkQueryResultFlagBits"/>
- <type name="VkQueryResultFlags"/>
- <type name="VkQueryType"/>
- <command name="vkCreateQueryPool"/>
- <command name="vkDestroyQueryPool"/>
- <command name="vkGetQueryPoolResults"/>
- </require>
- <require comment="Buffer commands">
- <type name="VkBuffer"/>
- <type name="VkBufferCreateFlagBits"/>
- <type name="VkBufferCreateFlags"/>
- <type name="VkBufferCreateInfo"/>
- <type name="VkBufferUsageFlagBits"/>
- <type name="VkBufferUsageFlags"/>
- <type name="VkSharingMode"/>
- <command name="vkCreateBuffer"/>
- <command name="vkDestroyBuffer"/>
- </require>
- <require comment="Buffer view commands">
- <type name="VkBufferView"/>
- <type name="VkBufferViewCreateFlags" comment="Will add VkBufferViewFlagBits when bits are defined in the future"/>
- <type name="VkBufferViewCreateInfo"/>
- <command name="vkCreateBufferView"/>
- <command name="vkDestroyBufferView"/>
- </require>
- <require comment="Image commands">
- <type name="VkImage"/>
- <type name="VkImageCreateInfo"/>
- <type name="VkImageLayout"/>
- <type name="VkSubresourceLayout"/>
- <command name="vkCreateImage"/>
- <command name="vkDestroyImage"/>
- <command name="vkGetImageSubresourceLayout"/>
- </require>
- <require comment="Image view commands">
- <type name="VkComponentMapping"/>
- <type name="VkComponentSwizzle"/>
- <type name="VkImageSubresourceRange"/>
- <type name="VkImageView"/>
- <type name="VkImageViewCreateFlagBits"/>
- <type name="VkImageViewCreateFlags"/>
- <type name="VkImageViewCreateInfo"/>
- <type name="VkImageViewType"/>
- <command name="vkCreateImageView"/>
- <command name="vkDestroyImageView"/>
- </require>
- <require comment="Shader commands">
- <type name="VkShaderModule"/>
- <type name="VkShaderModuleCreateFlags"/>
- <type name="VkShaderModuleCreateInfo"/>
- <command name="vkCreateShaderModule"/>
- <command name="vkDestroyShaderModule"/>
- </require>
- <require comment="Pipeline Cache commands">
- <type name="VkPipelineCache"/>
- <type name="VkPipelineCacheCreateFlags" comment="VkPipelineCacheCreateFlagBits was added later"/>
- <type name="VkPipelineCacheCreateInfo"/>
- <command name="vkCreatePipelineCache"/>
- <command name="vkDestroyPipelineCache"/>
- <command name="vkGetPipelineCacheData"/>
- <command name="vkMergePipelineCaches"/>
- </require>
- <require comment="Pipeline commands">
- <type name="VkBlendFactor"/>
- <type name="VkBlendOp"/>
- <type name="VkColorComponentFlagBits"/>
- <type name="VkColorComponentFlags"/>
- <type name="VkCompareOp"/>
- <type name="VkComputePipelineCreateInfo"/>
- <type name="VkCullModeFlagBits"/>
- <type name="VkCullModeFlags"/>
- <type name="VkDynamicState"/>
- <type name="VkFrontFace"/>
- <type name="VkGraphicsPipelineCreateInfo"/>
- <type name="VkLogicOp"/>
- <type name="VkPipeline"/>
- <type name="VkPipelineColorBlendAttachmentState"/>
- <type name="VkPipelineColorBlendStateCreateFlags" comment="Will add VkPipeline*StateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineColorBlendStateCreateInfo"/>
- <type name="VkPipelineCreateFlagBits"/>
- <type name="VkPipelineCreateFlags"/>
- <type name="VkPipelineDepthStencilStateCreateFlags" comment="Will add VkPipeline*StateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineDepthStencilStateCreateInfo"/>
- <type name="VkPipelineDynamicStateCreateFlags" comment="Will add VkPipeline*StateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineDynamicStateCreateInfo"/>
- <type name="VkPipelineInputAssemblyStateCreateFlags" comment="Will add VkPipeline*StateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineInputAssemblyStateCreateInfo"/>
- <type name="VkPipelineLayoutCreateFlags" comment="Will add VkPipelineLayoutCreateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineMultisampleStateCreateFlags" comment="Will add VkPipelineMultisampleStateCreateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineMultisampleStateCreateInfo"/>
- <type name="VkPipelineRasterizationStateCreateFlags" comment="Will add VkPipelineRasterizationStateCreateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineRasterizationStateCreateInfo"/>
- <type name="VkPipelineShaderStageCreateFlagBits"/>
- <type name="VkPipelineShaderStageCreateFlags"/>
- <type name="VkPipelineShaderStageCreateInfo"/>
- <type name="VkPipelineTessellationStateCreateFlags" comment="Will add VkPipelineTessellationStateCreateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineTessellationStateCreateInfo"/>
- <type name="VkPipelineVertexInputStateCreateFlags" comment="Will add VkPipelineVertexInputStateCreateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineVertexInputStateCreateInfo"/>
- <type name="VkPipelineViewportStateCreateFlags" comment="Will add VkPipelineViewportStateCreateFlagBits when bits are defined in the future"/>
- <type name="VkPipelineViewportStateCreateInfo"/>
- <type name="VkPolygonMode"/>
- <type name="VkPrimitiveTopology"/>
- <type name="VkSampleMask"/>
- <type name="VkShaderStageFlagBits"/>
- <type name="VkShaderStageFlags"/>
- <type name="VkSpecializationInfo"/>
- <type name="VkSpecializationMapEntry"/>
- <type name="VkStencilOp"/>
- <type name="VkStencilOpState"/>
- <type name="VkVertexInputAttributeDescription"/>
- <type name="VkVertexInputBindingDescription"/>
- <type name="VkVertexInputRate"/>
- <type name="VkViewport"/>
- <command name="vkCreateGraphicsPipelines"/>
- <command name="vkCreateComputePipelines"/>
- <command name="vkDestroyPipeline"/>
- </require>
- <require comment="Pipeline layout commands">
- <type name="VkPipelineLayout"/>
- <type name="VkPipelineLayoutCreateInfo"/>
- <type name="VkPushConstantRange"/>
- <command name="vkCreatePipelineLayout"/>
- <command name="vkDestroyPipelineLayout"/>
- </require>
- <require comment="Sampler commands">
- <type name="VkBorderColor"/>
- <type name="VkFilter"/>
- <type name="VkSampler"/>
- <type name="VkSamplerAddressMode"/>
- <type name="VkSamplerCreateFlagBits"/>
- <type name="VkSamplerCreateFlags"/>
- <type name="VkSamplerCreateInfo"/>
- <type name="VkSamplerMipmapMode"/>
- <command name="vkCreateSampler"/>
- <command name="vkDestroySampler"/>
- </require>
- <require comment="Descriptor set commands">
- <type name="VkCopyDescriptorSet"/>
- <type name="VkDescriptorBufferInfo"/>
- <type name="VkDescriptorImageInfo"/>
- <type name="VkDescriptorPool"/>
- <type name="VkDescriptorPoolCreateFlagBits"/>
- <type name="VkDescriptorPoolCreateFlags"/>
- <type name="VkDescriptorPoolCreateInfo"/>
- <type name="VkDescriptorPoolResetFlags"/>
- <type name="VkDescriptorPoolSize"/>
- <type name="VkDescriptorSet"/>
- <type name="VkDescriptorSetAllocateInfo"/>
- <type name="VkDescriptorSetLayout"/>
- <type name="VkDescriptorSetLayoutBinding"/>
- <type name="VkDescriptorSetLayoutCreateFlagBits"/>
- <type name="VkDescriptorSetLayoutCreateFlags"/>
- <type name="VkDescriptorSetLayoutCreateInfo"/>
- <type name="VkDescriptorType"/>
- <type name="VkWriteDescriptorSet"/>
- <command name="vkCreateDescriptorSetLayout"/>
- <command name="vkDestroyDescriptorSetLayout"/>
- <command name="vkCreateDescriptorPool"/>
- <command name="vkDestroyDescriptorPool"/>
- <command name="vkResetDescriptorPool"/>
- <command name="vkAllocateDescriptorSets"/>
- <command name="vkFreeDescriptorSets"/>
- <command name="vkUpdateDescriptorSets"/>
- </require>
- <require comment="Pass commands">
- <type name="VkAccessFlagBits"/>
- <type name="VkAccessFlags"/>
- <type name="VkAttachmentDescription"/>
- <type name="VkAttachmentDescriptionFlagBits"/>
- <type name="VkAttachmentDescriptionFlags"/>
- <type name="VkAttachmentLoadOp"/>
- <type name="VkAttachmentReference"/>
- <type name="VkAttachmentStoreOp"/>
- <type name="VkDependencyFlagBits"/>
- <type name="VkDependencyFlags"/>
- <type name="VkFramebuffer"/>
- <type name="VkFramebufferCreateFlagBits"/>
- <type name="VkFramebufferCreateFlags"/>
- <type name="VkFramebufferCreateInfo"/>
- <type name="VkPipelineBindPoint"/>
- <type name="VkRenderPass"/>
- <type name="VkRenderPassCreateFlagBits"/>
- <type name="VkRenderPassCreateFlags"/>
- <type name="VkRenderPassCreateInfo"/>
- <type name="VkSubpassDependency"/>
- <type name="VkSubpassDescription"/>
- <type name="VkSubpassDescriptionFlagBits"/>
- <type name="VkSubpassDescriptionFlags"/>
- <command name="vkCreateFramebuffer"/>
- <command name="vkDestroyFramebuffer"/>
- <command name="vkCreateRenderPass"/>
- <command name="vkDestroyRenderPass"/>
- <command name="vkGetRenderAreaGranularity"/>
- </require>
- <require comment="Command pool commands">
- <type name="VkCommandPool"/>
- <type name="VkCommandPoolCreateFlagBits"/>
- <type name="VkCommandPoolCreateFlags"/>
- <type name="VkCommandPoolCreateInfo"/>
- <type name="VkCommandPoolResetFlagBits"/>
- <type name="VkCommandPoolResetFlags"/>
- <command name="vkCreateCommandPool"/>
- <command name="vkDestroyCommandPool"/>
- <command name="vkResetCommandPool"/>
- </require>
- <require comment="Command buffer commands">
- <type name="VkCommandBuffer"/>
- <type name="VkCommandBufferAllocateInfo"/>
- <type name="VkCommandBufferBeginInfo"/>
- <type name="VkCommandBufferInheritanceInfo"/>
- <type name="VkCommandBufferLevel"/>
- <type name="VkCommandBufferResetFlagBits"/>
- <type name="VkCommandBufferResetFlags"/>
- <type name="VkCommandBufferUsageFlagBits"/>
- <type name="VkCommandBufferUsageFlags"/>
- <type name="VkQueryControlFlagBits"/>
- <type name="VkQueryControlFlags"/>
- <command name="vkAllocateCommandBuffers"/>
- <command name="vkFreeCommandBuffers"/>
- <command name="vkBeginCommandBuffer"/>
- <command name="vkEndCommandBuffer"/>
- <command name="vkResetCommandBuffer"/>
- </require>
- <require comment="Command buffer building commands">
- <type name="VkBufferCopy"/>
- <type name="VkBufferImageCopy"/>
- <type name="VkClearAttachment"/>
- <type name="VkClearColorValue"/>
- <type name="VkClearDepthStencilValue"/>
- <type name="VkClearRect"/>
- <type name="VkClearValue"/>
- <type name="VkImageBlit"/>
- <type name="VkImageCopy"/>
- <type name="VkImageResolve"/>
- <type name="VkImageSubresourceLayers"/>
- <type name="VkIndexType"/>
- <type name="VkRenderPassBeginInfo"/>
- <type name="VkStencilFaceFlagBits"/>
- <type name="VkStencilFaceFlags"/>
- <type name="VkSubpassContents"/>
- <command name="vkCmdBindPipeline"/>
- <command name="vkCmdSetViewport"/>
- <command name="vkCmdSetScissor"/>
- <command name="vkCmdSetLineWidth"/>
- <command name="vkCmdSetDepthBias"/>
- <command name="vkCmdSetBlendConstants"/>
- <command name="vkCmdSetDepthBounds"/>
- <command name="vkCmdSetStencilCompareMask"/>
- <command name="vkCmdSetStencilWriteMask"/>
- <command name="vkCmdSetStencilReference"/>
- <command name="vkCmdBindDescriptorSets"/>
- <command name="vkCmdBindIndexBuffer"/>
- <command name="vkCmdBindVertexBuffers"/>
- <command name="vkCmdDraw"/>
- <command name="vkCmdDrawIndexed"/>
- <command name="vkCmdDrawIndirect"/>
- <command name="vkCmdDrawIndexedIndirect"/>
- <command name="vkCmdDispatch"/>
- <command name="vkCmdDispatchIndirect"/>
- <command name="vkCmdCopyBuffer"/>
- <command name="vkCmdCopyImage"/>
- <command name="vkCmdBlitImage"/>
- <command name="vkCmdCopyBufferToImage"/>
- <command name="vkCmdCopyImageToBuffer"/>
- <command name="vkCmdUpdateBuffer"/>
- <command name="vkCmdFillBuffer"/>
- <command name="vkCmdClearColorImage"/>
- <command name="vkCmdClearDepthStencilImage"/>
- <command name="vkCmdClearAttachments"/>
- <command name="vkCmdResolveImage"/>
- <command name="vkCmdSetEvent"/>
- <command name="vkCmdResetEvent"/>
- <command name="vkCmdWaitEvents"/>
- <command name="vkCmdPipelineBarrier"/>
- <command name="vkCmdBeginQuery"/>
- <command name="vkCmdEndQuery"/>
- <command name="vkCmdResetQueryPool"/>
- <command name="vkCmdWriteTimestamp"/>
- <command name="vkCmdCopyQueryPoolResults"/>
- <command name="vkCmdPushConstants"/>
- <command name="vkCmdBeginRenderPass"/>
- <command name="vkCmdNextSubpass"/>
- <command name="vkCmdEndRenderPass"/>
- <command name="vkCmdExecuteCommands"/>
- </require>
- </feature>
- <feature api="vulkan" name="VK_VERSION_1_1" number="1.1" comment="Vulkan 1.1 core API interface definitions.">
- <require>
- <type name="VK_API_VERSION_1_1"/>
- </require>
- <require comment="Device Initialization">
- <command name="vkEnumerateInstanceVersion"/>
- </require>
- <require comment="Promoted from VK_KHR_relaxed_block_layout, which has no API"/>
- <require comment="Promoted from VK_KHR_storage_buffer_storage_class, which has no API"/>
- <require comment="Originally based on VK_KHR_subgroup (extension 94), but the actual enum block used was, incorrectly, that of extension 95">
- <enum extends="VkStructureType" extnumber="95" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"/>
- <type name="VkPhysicalDeviceSubgroupProperties"/>
- <type name="VkSubgroupFeatureFlags"/>
- <type name="VkSubgroupFeatureFlagBits"/>
- </require>
- <require comment="Promoted from VK_KHR_bind_memory2">
- <command name="vkBindBufferMemory2"/>
- <command name="vkBindImageMemory2"/>
- <enum extends="VkStructureType" extnumber="158" offset="0" name="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"/>
- <enum extends="VkStructureType" extnumber="158" offset="1" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"/>
- <enum bitpos="10" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_ALIAS_BIT"/>
- <type name="VkBindBufferMemoryInfo"/>
- <type name="VkBindImageMemoryInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_16bit_storage">
- <enum extends="VkStructureType" extnumber="84" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"/>
- <type name="VkPhysicalDevice16BitStorageFeatures"/>
- </require>
- <require comment="Promoted from VK_KHR_dedicated_allocation">
- <enum extends="VkStructureType" extnumber="128" offset="0" name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"/>
- <enum extends="VkStructureType" extnumber="128" offset="1" name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"/>
- <type name="VkMemoryDedicatedRequirements"/>
- <type name="VkMemoryDedicatedAllocateInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_device_group">
- <enum extends="VkStructureType" extnumber="61" offset="0" name="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"/>
- <comment>offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum</comment>
- <comment>offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum</comment>
- <enum extends="VkStructureType" extnumber="61" offset="3" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"/>
- <enum extends="VkStructureType" extnumber="61" offset="4" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"/>
- <enum extends="VkStructureType" extnumber="61" offset="5" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"/>
- <enum extends="VkStructureType" extnumber="61" offset="6" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO"/>
- <type name="VkPeerMemoryFeatureFlags"/>
- <type name="VkPeerMemoryFeatureFlagBits"/>
- <type name="VkMemoryAllocateFlags"/>
- <type name="VkMemoryAllocateFlagBits"/>
- <type name="VkMemoryAllocateFlagsInfo"/>
- <type name="VkDeviceGroupRenderPassBeginInfo"/>
- <type name="VkDeviceGroupCommandBufferBeginInfo"/>
- <type name="VkDeviceGroupSubmitInfo"/>
- <type name="VkDeviceGroupBindSparseInfo"/>
- <command name="vkGetDeviceGroupPeerMemoryFeatures"/>
- <command name="vkCmdSetDeviceMask"/>
- <command name="vkCmdDispatchBase"/>
- <enum bitpos="3" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"/>
- <enum bitpos="4" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"/>
- <enum extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_DISPATCH_BASE" alias="VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"/>
- <enum bitpos="2" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_DEVICE_GROUP_BIT" comment="Dependency is across devices"/>
- </require>
- <require comment="Promoted from VK_KHR_device_group + VK_KHR_bind_memory2">
- <enum extends="VkStructureType" extnumber="61" offset="13" name="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"/>
- <enum extends="VkStructureType" extnumber="61" offset="14" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"/>
- <type name="VkBindBufferMemoryDeviceGroupInfo"/>
- <type name="VkBindImageMemoryDeviceGroupInfo"/>
- <enum bitpos="6" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT" comment="Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image"/>
- </require>
- <require comment="Promoted from VK_KHR_device_group_creation">
- <enum extends="VkStructureType" extnumber="71" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"/>
- <enum extends="VkStructureType" extnumber="71" offset="1" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"/>
- <enum name="VK_MAX_DEVICE_GROUP_SIZE"/>
- <type name="VkPhysicalDeviceGroupProperties"/>
- <type name="VkDeviceGroupDeviceCreateInfo"/>
- <command name="vkEnumeratePhysicalDeviceGroups"/>
- <enum bitpos="1" extends="VkMemoryHeapFlagBits" name="VK_MEMORY_HEAP_MULTI_INSTANCE_BIT" comment="If set, heap allocations allocate multiple instances by default"/>
- </require>
- <require comment="Promoted from VK_KHR_get_memory_requirements2">
- <enum extends="VkStructureType" extnumber="147" offset="0" name="VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"/>
- <enum extends="VkStructureType" extnumber="147" offset="1" name="VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"/>
- <enum extends="VkStructureType" extnumber="147" offset="2" name="VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2"/>
- <enum extends="VkStructureType" extnumber="147" offset="3" name="VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"/>
- <enum extends="VkStructureType" extnumber="147" offset="4" name="VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"/>
- <type name="VkBufferMemoryRequirementsInfo2"/>
- <type name="VkImageMemoryRequirementsInfo2"/>
- <type name="VkImageSparseMemoryRequirementsInfo2"/>
- <type name="VkMemoryRequirements2"/>
- <type name="VkSparseImageMemoryRequirements2"/>
- <command name="vkGetImageMemoryRequirements2"/>
- <command name="vkGetBufferMemoryRequirements2"/>
- <command name="vkGetImageSparseMemoryRequirements2"/>
- </require>
- <require comment="Promoted from VK_KHR_get_physical_device_properties2">
- <enum extends="VkStructureType" extnumber="60" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="1" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="2" name="VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="3" name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="4" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="5" name="VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="6" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="7" name="VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2"/>
- <enum extends="VkStructureType" extnumber="60" offset="8" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2"/>
- <type name="VkPhysicalDeviceFeatures2"/>
- <type name="VkPhysicalDeviceProperties2"/>
- <type name="VkFormatProperties2"/>
- <type name="VkImageFormatProperties2"/>
- <type name="VkPhysicalDeviceImageFormatInfo2"/>
- <type name="VkQueueFamilyProperties2"/>
- <type name="VkPhysicalDeviceMemoryProperties2"/>
- <type name="VkSparseImageFormatProperties2"/>
- <type name="VkPhysicalDeviceSparseImageFormatInfo2"/>
- <command name="vkGetPhysicalDeviceFeatures2"/>
- <command name="vkGetPhysicalDeviceProperties2"/>
- <command name="vkGetPhysicalDeviceFormatProperties2"/>
- <command name="vkGetPhysicalDeviceImageFormatProperties2"/>
- <command name="vkGetPhysicalDeviceQueueFamilyProperties2"/>
- <command name="vkGetPhysicalDeviceMemoryProperties2"/>
- <command name="vkGetPhysicalDeviceSparseImageFormatProperties2"/>
- </require>
- <require comment="Promoted from VK_KHR_maintenance1">
- <enum extends="VkResult" extnumber="70" offset="0" dir="-" name="VK_ERROR_OUT_OF_POOL_MEMORY"/>
- <enum bitpos="14" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_TRANSFER_SRC_BIT" comment="Format can be used as the source image of image transfer commands"/>
- <enum bitpos="15" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_TRANSFER_DST_BIT" comment="Format can be used as the destination image of image transfer commands"/>
- <enum bitpos="5" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT" comment="The 3D image can be viewed as a 2D or 2D array image"/>
- <command name="vkTrimCommandPool"/>
- <comment>Additional dependent types / tokens extending enumerants, not explicitly mentioned</comment>
- <type name="VkCommandPoolTrimFlags"/>
- </require>
- <require comment="Promoted from VK_KHR_maintenance2">
- <enum bitpos="7" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"/>
- <enum bitpos="8" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"/>
- <enum extends="VkStructureType" extnumber="118" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"/>
- <enum extends="VkStructureType" extnumber="118" offset="1" name="VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"/>
- <enum extends="VkStructureType" extnumber="118" offset="2" name="VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"/>
- <enum extends="VkStructureType" extnumber="118" offset="3" name="VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"/>
- <enum extends="VkImageLayout" extnumber="118" offset="0" name="VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"/>
- <enum extends="VkImageLayout" extnumber="118" offset="1" name="VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"/>
- <type name="VkPhysicalDevicePointClippingProperties"/>
- <type name="VkPointClippingBehavior"/>
- <type name="VkRenderPassInputAttachmentAspectCreateInfo"/>
- <type name="VkInputAttachmentAspectReference"/>
- <type name="VkImageViewUsageCreateInfo"/>
- <type name="VkTessellationDomainOrigin"/>
- <type name="VkPipelineTessellationDomainOriginStateCreateInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_multiview">
- <enum extends="VkStructureType" extnumber="54" offset="0" name="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"/>
- <enum extends="VkStructureType" extnumber="54" offset="1" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"/>
- <enum extends="VkStructureType" extnumber="54" offset="2" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"/>
- <enum bitpos="1" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_VIEW_LOCAL_BIT"/>
- <type name="VkRenderPassMultiviewCreateInfo"/>
- <type name="VkPhysicalDeviceMultiviewFeatures"/>
- <type name="VkPhysicalDeviceMultiviewProperties"/>
- </require>
- <require comment="Promoted from VK_KHR_variable_pointers">
- <enum extends="VkStructureType" extnumber="121" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"/>
- <type name="VkPhysicalDeviceVariablePointerFeatures"/>
- <type name="VkPhysicalDeviceVariablePointersFeatures"/>
- </require>
- <require comment="Originally based on VK_KHR_protected_memory (extension 146), which was never published; thus the mystifying large value= numbers below. These are not aliased since they weren't actually promoted from an extension.">
- <enum extends="VkStructureType" extnumber="146" offset="0" name="VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"/>
- <enum extends="VkStructureType" extnumber="146" offset="1" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"/>
- <enum extends="VkStructureType" extnumber="146" offset="2" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"/>
- <enum extends="VkStructureType" extnumber="146" offset="3" name="VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"/>
- <enum bitpos="4" extends="VkQueueFlagBits" name="VK_QUEUE_PROTECTED_BIT" comment="Queues may support protected operations"/>
- <enum bitpos="0" extends="VkDeviceQueueCreateFlagBits" name="VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT" comment="Queue is a protected-capable device queue"/>
- <type name="VkDeviceQueueCreateFlagBits" comment="This is a temporary workaround for processors not recognizing that VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT above also requires this type"/>
- <enum bitpos="5" extends="VkMemoryPropertyFlagBits" name="VK_MEMORY_PROPERTY_PROTECTED_BIT" comment="Memory is protected"/>
- <enum bitpos="3" extends="VkBufferCreateFlagBits" name="VK_BUFFER_CREATE_PROTECTED_BIT" comment="Buffer requires protected memory"/>
- <enum bitpos="11" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_PROTECTED_BIT" comment="Image requires protected memory"/>
- <enum bitpos="2" extends="VkCommandPoolCreateFlagBits" name="VK_COMMAND_POOL_CREATE_PROTECTED_BIT" comment="Command buffers allocated from pool are protected command buffers"/>
- <type name="VkPhysicalDeviceProtectedMemoryFeatures"/>
- <type name="VkPhysicalDeviceProtectedMemoryProperties"/>
- <type name="VkDeviceQueueInfo2"/>
- <type name="VkProtectedSubmitInfo"/>
- <command name="vkGetDeviceQueue2"/>
- </require>
- <require comment="Promoted from VK_KHR_sampler_ycbcr_conversion">
- <enum extends="VkStructureType" extnumber="157" offset="0" name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"/>
- <enum extends="VkStructureType" extnumber="157" offset="1" name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"/>
- <enum extends="VkStructureType" extnumber="157" offset="2" name="VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"/>
- <enum extends="VkStructureType" extnumber="157" offset="3" name="VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"/>
- <enum extends="VkStructureType" extnumber="157" offset="4" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"/>
- <enum extends="VkStructureType" extnumber="157" offset="5" name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"/>
- <enum extends="VkObjectType" extnumber="157" offset="0" name="VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"/>
- <enum extends="VkFormat" extnumber="157" offset="0" name="VK_FORMAT_G8B8G8R8_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="1" name="VK_FORMAT_B8G8R8G8_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="2" name="VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="3" name="VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="4" name="VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="5" name="VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="6" name="VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="7" name="VK_FORMAT_R10X6_UNORM_PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="8" name="VK_FORMAT_R10X6G10X6_UNORM_2PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="9" name="VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="10" name="VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="11" name="VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="12" name="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="13" name="VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="14" name="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="15" name="VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="16" name="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="17" name="VK_FORMAT_R12X4_UNORM_PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="18" name="VK_FORMAT_R12X4G12X4_UNORM_2PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="19" name="VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="20" name="VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="21" name="VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="22" name="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="23" name="VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="24" name="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="25" name="VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="26" name="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"/>
- <enum extends="VkFormat" extnumber="157" offset="27" name="VK_FORMAT_G16B16G16R16_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="28" name="VK_FORMAT_B16G16R16G16_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="29" name="VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="30" name="VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="31" name="VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="32" name="VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"/>
- <enum extends="VkFormat" extnumber="157" offset="33" name="VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"/>
- <enum bitpos="4" extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_PLANE_0_BIT"/>
- <enum bitpos="5" extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_PLANE_1_BIT"/>
- <enum bitpos="6" extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_PLANE_2_BIT"/>
- <enum bitpos="9" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_DISJOINT_BIT"/>
- <enum bitpos="17" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT" comment="Format can have midpoint rather than cosited chroma samples"/>
- <enum bitpos="18" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT" comment="Format can be used with linear filtering whilst color conversion is enabled"/>
- <enum bitpos="19" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT" comment="Format can have different chroma, min and mag filters"/>
- <enum bitpos="20" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"/>
- <enum bitpos="21" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"/>
- <enum bitpos="22" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_DISJOINT_BIT" comment="Format supports disjoint planes"/>
- <enum bitpos="23" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT" comment="Format can have cosited rather than midpoint chroma samples"/>
- <type name="VkSamplerYcbcrConversionCreateInfo"/>
- <type name="VkSamplerYcbcrConversionInfo"/>
- <type name="VkBindImagePlaneMemoryInfo"/>
- <type name="VkImagePlaneMemoryRequirementsInfo"/>
- <type name="VkPhysicalDeviceSamplerYcbcrConversionFeatures"/>
- <type name="VkSamplerYcbcrConversionImageFormatProperties"/>
- <command name="vkCreateSamplerYcbcrConversion"/>
- <command name="vkDestroySamplerYcbcrConversion"/>
- <comment>Additional dependent types / tokens extending enumerants, not explicitly mentioned</comment>
- <type name="VkSamplerYcbcrConversion"/>
- <type name="VkSamplerYcbcrModelConversion"/>
- <type name="VkSamplerYcbcrRange"/>
- <type name="VkChromaLocation"/>
- </require>
- <require comment="Promoted from VK_KHR_descriptor_update_template">
- <enum extends="VkStructureType" extnumber="86" offset="0" name="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO"/>
- <enum extends="VkObjectType" extnumber="86" offset="0" name="VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE"/>
- <command name="vkCreateDescriptorUpdateTemplate"/>
- <command name="vkDestroyDescriptorUpdateTemplate"/>
- <command name="vkUpdateDescriptorSetWithTemplate"/>
- <type name="VkDescriptorUpdateTemplate"/>
- <type name="VkDescriptorUpdateTemplateCreateFlags"/>
- <type name="VkDescriptorUpdateTemplateType"/>
- <type name="VkDescriptorUpdateTemplateEntry"/>
- <type name="VkDescriptorUpdateTemplateCreateInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_external_memory_capabilities">
- <enum extends="VkStructureType" extnumber="72" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"/>
- <enum extends="VkStructureType" extnumber="72" offset="1" name="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"/>
- <enum extends="VkStructureType" extnumber="72" offset="2" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"/>
- <enum extends="VkStructureType" extnumber="72" offset="3" name="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"/>
- <enum extends="VkStructureType" extnumber="72" offset="4" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"/>
- <enum name="VK_LUID_SIZE"/>
- <type name="VkExternalMemoryHandleTypeFlags"/>
- <type name="VkExternalMemoryHandleTypeFlagBits"/>
- <type name="VkExternalMemoryFeatureFlags"/>
- <type name="VkExternalMemoryFeatureFlagBits"/>
- <type name="VkExternalMemoryProperties"/>
- <type name="VkPhysicalDeviceExternalImageFormatInfo"/>
- <type name="VkExternalImageFormatProperties"/>
- <type name="VkPhysicalDeviceExternalBufferInfo"/>
- <type name="VkExternalBufferProperties"/>
- <type name="VkPhysicalDeviceIDProperties"/>
- <command name="vkGetPhysicalDeviceExternalBufferProperties"/>
- </require>
- <require comment="Promoted from VK_KHR_external_memory">
- <enum extends="VkStructureType" extnumber="73" offset="0" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"/>
- <enum extends="VkStructureType" extnumber="73" offset="1" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"/>
- <enum extends="VkStructureType" extnumber="73" offset="2" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"/>
- <enum extends="VkResult" extnumber="73" offset="3" dir="-" name="VK_ERROR_INVALID_EXTERNAL_HANDLE"/>
- <enum name="VK_QUEUE_FAMILY_EXTERNAL"/>
- <type name="VkExternalMemoryImageCreateInfo"/>
- <type name="VkExternalMemoryBufferCreateInfo"/>
- <type name="VkExportMemoryAllocateInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_external_fence_capabilities">
- <enum extends="VkStructureType" extnumber="113" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"/>
- <enum extends="VkStructureType" extnumber="113" offset="1" name="VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"/>
- <type name="VkExternalFenceHandleTypeFlags"/>
- <type name="VkExternalFenceHandleTypeFlagBits"/>
- <type name="VkExternalFenceFeatureFlags"/>
- <type name="VkExternalFenceFeatureFlagBits"/>
- <type name="VkPhysicalDeviceExternalFenceInfo"/>
- <type name="VkExternalFenceProperties"/>
- <command name="vkGetPhysicalDeviceExternalFenceProperties"/>
- </require>
- <require comment="Promoted from VK_KHR_external_fence">
- <enum extends="VkStructureType" extnumber="114" offset="0" name="VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"/>
- <type name="VkFenceImportFlags"/>
- <type name="VkFenceImportFlagBits"/>
- <type name="VkExportFenceCreateInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_external_semaphore">
- <enum extends="VkStructureType" extnumber="78" offset="0" name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"/>
- <type name="VkSemaphoreImportFlags"/>
- <type name="VkSemaphoreImportFlagBits"/>
- <type name="VkExportSemaphoreCreateInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_external_semaphore_capabilities">
- <enum extends="VkStructureType" extnumber="77" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"/>
- <enum extends="VkStructureType" extnumber="77" offset="1" name="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"/>
- <type name="VkExternalSemaphoreHandleTypeFlags"/>
- <type name="VkExternalSemaphoreHandleTypeFlagBits"/>
- <type name="VkExternalSemaphoreFeatureFlags"/>
- <type name="VkExternalSemaphoreFeatureFlagBits"/>
- <type name="VkPhysicalDeviceExternalSemaphoreInfo"/>
- <type name="VkExternalSemaphoreProperties"/>
- <command name="vkGetPhysicalDeviceExternalSemaphoreProperties"/>
- </require>
- <require comment="Promoted from VK_KHR_maintenance3">
- <enum extends="VkStructureType" extnumber="169" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"/>
- <enum extends="VkStructureType" extnumber="169" offset="1" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"/>
- <type name="VkPhysicalDeviceMaintenance3Properties"/>
- <type name="VkDescriptorSetLayoutSupport"/>
- <command name="vkGetDescriptorSetLayoutSupport"/>
- </require>
- <require comment="Promoted from VK_KHR_shader_draw_parameters, with a feature support query added">
- <enum extends="VkStructureType" extnumber="64" offset="0" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"/>
- <type name="VkPhysicalDeviceShaderDrawParameterFeatures"/>
- <type name="VkPhysicalDeviceShaderDrawParametersFeatures"/>
- </require>
- </feature>
- <feature api="vulkan" name="VK_VERSION_1_2" number="1.2" comment="Vulkan 1.2 core API interface definitions.">
- <require>
- <type name="VK_API_VERSION_1_2"/>
- </require>
- <require>
- <enum extends="VkStructureType" value="49" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"/>
- <enum extends="VkStructureType" value="50" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"/>
- <enum extends="VkStructureType" value="51" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"/>
- <enum extends="VkStructureType" value="52" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"/>
- <type name="VkPhysicalDeviceVulkan11Features"/>
- <type name="VkPhysicalDeviceVulkan11Properties"/>
- <type name="VkPhysicalDeviceVulkan12Features"/>
- <type name="VkPhysicalDeviceVulkan12Properties"/>
- </require>
- <require comment="Promoted from VK_KHR_image_format_list (extension 148)">
- <enum offset="0" extends="VkStructureType" extnumber="148" name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"/>
- <type name="VkImageFormatListCreateInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_sampler_mirror_clamp_to_edge (extension 15)">
- <enum value="4" extends="VkSamplerAddressMode" name="VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" comment="No need to add an extnumber attribute, since this uses a core enum value"/>
- </require>
- <require comment="Promoted from VK_KHR_draw_indirect_count (extension 170)">
- <command name="vkCmdDrawIndirectCount"/>
- <command name="vkCmdDrawIndexedIndirectCount"/>
- </require>
- <require comment="Promoted from VK_KHR_create_renderpass2 (extension 110)">
- <enum offset="0" extends="VkStructureType" extnumber="110" name="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"/>
- <enum offset="1" extends="VkStructureType" extnumber="110" name="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"/>
- <enum offset="2" extends="VkStructureType" extnumber="110" name="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"/>
- <enum offset="3" extends="VkStructureType" extnumber="110" name="VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"/>
- <enum offset="4" extends="VkStructureType" extnumber="110" name="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"/>
- <enum offset="5" extends="VkStructureType" extnumber="110" name="VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"/>
- <enum offset="6" extends="VkStructureType" extnumber="110" name="VK_STRUCTURE_TYPE_SUBPASS_END_INFO"/>
- <command name="vkCreateRenderPass2"/>
- <command name="vkCmdBeginRenderPass2"/>
- <command name="vkCmdNextSubpass2"/>
- <command name="vkCmdEndRenderPass2"/>
- <type name="VkRenderPassCreateInfo2"/>
- <type name="VkAttachmentDescription2"/>
- <type name="VkAttachmentReference2"/>
- <type name="VkSubpassDescription2"/>
- <type name="VkSubpassDependency2"/>
- <type name="VkSubpassBeginInfo"/>
- <type name="VkSubpassEndInfo"/>
- </require>
- <require comment="Promoted from VK_KHR_8bit_storage (extension 178)">
- <enum offset="0" extends="VkStructureType" extnumber="178" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"/>
- <type name="VkPhysicalDevice8BitStorageFeatures"/>
- </require>
- <require comment="Promoted from VK_KHR_driver_properties (extension 197)">
- <enum offset="0" extends="VkStructureType" extnumber="197" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"/>
- <enum name="VK_MAX_DRIVER_NAME_SIZE"/>
- <enum name="VK_MAX_DRIVER_INFO_SIZE"/>
- <type name="VkDriverId"/>
- <type name="VkConformanceVersion"/>
- <type name="VkPhysicalDeviceDriverProperties"/>
- </require>
- <require comment="Promoted from VK_KHR_shader_atomic_int64 (extension 181)">
- <enum offset="0" extends="VkStructureType" extnumber="181" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"/>
- <type name="VkPhysicalDeviceShaderAtomicInt64Features"/>
- </require>
- <require comment="Promoted from VK_KHR_shader_float16_int8 (extension 83)">
- <enum offset="0" extends="VkStructureType" extnumber="83" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"/>
- <type name="VkPhysicalDeviceShaderFloat16Int8Features"/>
- </require>
- <require comment="Promoted from VK_KHR_shader_float_controls (extension 198)">
- <enum offset="0" extends="VkStructureType" extnumber="198" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"/>
- <type name="VkPhysicalDeviceFloatControlsProperties"/>
- <type name="VkShaderFloatControlsIndependence"/>
- </require>
- <require comment="Promoted from VK_EXT_descriptor_indexing (extension 162)">
- <enum offset="0" extends="VkStructureType" extnumber="162" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"/>
- <enum offset="1" extends="VkStructureType" extnumber="162" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"/>
- <enum offset="2" extends="VkStructureType" extnumber="162" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"/>
- <enum offset="3" extends="VkStructureType" extnumber="162" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"/>
- <enum offset="4" extends="VkStructureType" extnumber="162" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"/>
- <enum bitpos="1" extends="VkDescriptorPoolCreateFlagBits" name="VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"/>
- <enum bitpos="1" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"/>
- <enum offset="0" dir="-" extends="VkResult" extnumber="162" name="VK_ERROR_FRAGMENTATION"/>
- <type name="VkDescriptorSetLayoutBindingFlagsCreateInfo"/>
- <type name="VkPhysicalDeviceDescriptorIndexingFeatures"/>
- <type name="VkPhysicalDeviceDescriptorIndexingProperties"/>
- <type name="VkDescriptorSetVariableDescriptorCountAllocateInfo"/>
- <type name="VkDescriptorSetVariableDescriptorCountLayoutSupport"/>
- <type name="VkDescriptorBindingFlagBits"/>
- <type name="VkDescriptorBindingFlags"/>
- </require>
- <require comment="Promoted from VK_KHR_depth_stencil_resolve (extension 200)">
- <enum offset="0" extends="VkStructureType" extnumber="200" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"/>
- <enum offset="1" extends="VkStructureType" extnumber="200" name="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"/>
- <type name="VkSubpassDescriptionDepthStencilResolve"/>
- <type name="VkPhysicalDeviceDepthStencilResolveProperties"/>
- <type name="VkResolveModeFlagBits"/>
- <type name="VkResolveModeFlags"/>
- </require>
- <require comment="Promoted from VK_EXT_scalar_block_layout (extension 222))">
- <type name="VkPhysicalDeviceScalarBlockLayoutFeatures"/>
- <enum offset="0" extends="VkStructureType" extnumber="222" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"/>
- </require>
- <require comment="Promoted from VK_EXT_shader_viewport_index_layer, which has no API (extension 163)"/>
- <require comment="Promoted from VK_EXT_separate_stencil_usage (extension 247)">
- <enum offset="0" extends="VkStructureType" extnumber="247" name="VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"/>
- <type name="VkImageStencilUsageCreateInfo"/>
- </require>
- <require comment="Promoted from VK_EXT_sampler_filter_minmax (extension 131)">
- <enum offset="0" extends="VkStructureType" extnumber="131" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"/>
- <enum offset="1" extends="VkStructureType" extnumber="131" name="VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"/>
- <enum bitpos="16" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT" comment="Format can be used with min/max reduction filtering"/>
- <type name="VkSamplerReductionMode"/>
- <type name="VkSamplerReductionModeCreateInfo"/>
- <type name="VkPhysicalDeviceSamplerFilterMinmaxProperties"/>
- </require>
- <require comment="Promoted from VK_KHR_vulkan_memory_model (extension 212)">
- <enum offset="0" extends="VkStructureType" extnumber="212" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"/>
- <type name="VkPhysicalDeviceVulkanMemoryModelFeatures"/>
- </require>
- <require comment="Promoted from VK_KHR_imageless_framebuffer (extension 109)">
- <type name="VkPhysicalDeviceImagelessFramebufferFeatures"/>
- <type name="VkFramebufferAttachmentsCreateInfo"/>
- <type name="VkFramebufferAttachmentImageInfo"/>
- <type name="VkRenderPassAttachmentBeginInfo"/>
- <enum offset="0" extends="VkStructureType" extnumber="109" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"/>
- <enum offset="1" extends="VkStructureType" extnumber="109" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"/>
- <enum offset="2" extends="VkStructureType" extnumber="109" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"/>
- <enum offset="3" extends="VkStructureType" extnumber="109" name="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"/>
- <enum bitpos="0" extends="VkFramebufferCreateFlagBits" name="VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"/>
- </require>
- <require comment="Promoted from VK_KHR_uniform_buffer_standard_layout (extension 254)">
- <type name="VkPhysicalDeviceUniformBufferStandardLayoutFeatures"/>
- <enum offset="0" extends="VkStructureType" extnumber="254" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"/>
- </require>
- <require comment="Promoted from VK_KHR_shader_subgroup_extended_types (extension 176)">
- <enum offset="0" extends="VkStructureType" extnumber="176" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"/>
- <type name="VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"/>
- </require>
- <require comment="Promoted from VK_KHR_spirv_1_4 (extension 237)">
- </require>
- <require comment="Promoted from VK_KHR_separate_depth_stencil_layouts (extension 242)">
- <enum offset="0" extends="VkStructureType" extnumber="242" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"/>
- <enum offset="1" extends="VkStructureType" extnumber="242" name="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"/>
- <enum offset="2" extends="VkStructureType" extnumber="242" name="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"/>
- <enum offset="0" extends="VkImageLayout" extnumber="242" name="VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"/>
- <enum offset="1" extends="VkImageLayout" extnumber="242" name="VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"/>
- <enum offset="2" extends="VkImageLayout" extnumber="242" name="VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"/>
- <enum offset="3" extends="VkImageLayout" extnumber="242" name="VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"/>
- <type name="VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"/>
- <type name="VkAttachmentReferenceStencilLayout"/>
- <type name="VkAttachmentDescriptionStencilLayout"/>
- </require>
- <require comment="Promoted from VK_EXT_host_query_reset (extension 262)">
- <enum offset="0" extends="VkStructureType" extnumber="262" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"/>
- <type name="VkPhysicalDeviceHostQueryResetFeatures"/>
- <command name="vkResetQueryPool"/>
- </require>
- <require comment="Promoted from VK_KHR_timeline_semaphore (extension 208)">
- <enum offset="0" extends="VkStructureType" extnumber="208" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"/>
- <enum offset="1" extends="VkStructureType" extnumber="208" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"/>
- <enum offset="2" extends="VkStructureType" extnumber="208" name="VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"/>
- <enum offset="3" extends="VkStructureType" extnumber="208" name="VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"/>
- <enum offset="4" extends="VkStructureType" extnumber="208" name="VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"/>
- <enum offset="5" extends="VkStructureType" extnumber="208" name="VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"/>
- <type name="VkSemaphoreType"/>
- <type name="VkPhysicalDeviceTimelineSemaphoreFeatures"/>
- <type name="VkPhysicalDeviceTimelineSemaphoreProperties"/>
- <type name="VkSemaphoreTypeCreateInfo"/>
- <type name="VkTimelineSemaphoreSubmitInfo"/>
- <type name="VkSemaphoreWaitFlagBits"/>
- <type name="VkSemaphoreWaitFlags"/>
- <type name="VkSemaphoreWaitInfo"/>
- <type name="VkSemaphoreSignalInfo"/>
- <command name="vkGetSemaphoreCounterValue"/>
- <command name="vkWaitSemaphores"/>
- <command name="vkSignalSemaphore"/>
- </require>
- <require comment="Promoted from VK_KHR_buffer_device_address (extension 258)">
- <enum offset="0" extends="VkStructureType" extnumber="258" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"/>
- <enum offset="1" extends="VkStructureType" extnumber="245" name="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"/>
- <enum offset="2" extends="VkStructureType" extnumber="258" name="VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"/>
- <enum offset="3" extends="VkStructureType" extnumber="258" name="VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"/>
- <enum offset="4" extends="VkStructureType" extnumber="258" name="VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"/>
- <enum bitpos="17" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"/>
- <enum bitpos="4" extends="VkBufferCreateFlagBits" name="VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"/>
- <enum bitpos="1" extends="VkMemoryAllocateFlagBits" name="VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"/>
- <enum bitpos="2" extends="VkMemoryAllocateFlagBits" name="VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"/>
- <enum offset="0" dir="-" extends="VkResult" extnumber="258" name="VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"/>
- <type name="VkPhysicalDeviceBufferDeviceAddressFeatures"/>
- <type name="VkBufferDeviceAddressInfo"/>
- <type name="VkBufferOpaqueCaptureAddressCreateInfo"/>
- <type name="VkMemoryOpaqueCaptureAddressAllocateInfo"/>
- <type name="VkDeviceMemoryOpaqueCaptureAddressInfo"/>
- <command name="vkGetBufferDeviceAddress"/>
- <command name="vkGetBufferOpaqueCaptureAddress"/>
- <command name="vkGetDeviceMemoryOpaqueCaptureAddress"/>
- </require>
- </feature>
-
- <extensions comment="Vulkan extension interface definitions">
- <extension name="VK_KHR_surface" number="1" type="instance" author="KHR" contact="James Jones @cubanismo,Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="25" name="VK_KHR_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_KHR_surface"" name="VK_KHR_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkResult" dir="-" name="VK_ERROR_SURFACE_LOST_KHR"/>
- <enum offset="1" extends="VkResult" dir="-" name="VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_SURFACE_KHR"/>
- <type name="VkSurfaceKHR"/>
- <type name="VkSurfaceTransformFlagBitsKHR"/>
- <type name="VkPresentModeKHR"/>
- <type name="VkColorSpaceKHR"/>
- <type name="VkCompositeAlphaFlagBitsKHR"/>
- <type name="VkCompositeAlphaFlagsKHR"/>
- <type name="VkSurfaceCapabilitiesKHR"/>
- <type name="VkSurfaceFormatKHR"/>
- <command name="vkDestroySurfaceKHR"/>
- <command name="vkGetPhysicalDeviceSurfaceSupportKHR"/>
- <command name="vkGetPhysicalDeviceSurfaceCapabilitiesKHR"/>
- <command name="vkGetPhysicalDeviceSurfaceFormatsKHR"/>
- <command name="vkGetPhysicalDeviceSurfacePresentModesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_swapchain" number="2" type="device" requires="VK_KHR_surface" author="KHR" contact="James Jones @cubanismo,Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="70" name="VK_KHR_SWAPCHAIN_SPEC_VERSION"/>
- <enum value=""VK_KHR_swapchain"" name="VK_KHR_SWAPCHAIN_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"/>
- <enum offset="2" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_PRESENT_SRC_KHR"/>
- <enum offset="3" extends="VkResult" name="VK_SUBOPTIMAL_KHR"/>
- <enum offset="4" extends="VkResult" dir="-" name="VK_ERROR_OUT_OF_DATE_KHR"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_SWAPCHAIN_KHR"/>
- <type name="VkSwapchainCreateFlagBitsKHR"/>
- <type name="VkSwapchainCreateFlagsKHR"/>
- <type name="VkSwapchainCreateInfoKHR"/>
- <type name="VkSwapchainKHR"/>
- <type name="VkPresentInfoKHR"/>
- <command name="vkCreateSwapchainKHR"/>
- <command name="vkDestroySwapchainKHR"/>
- <command name="vkGetSwapchainImagesKHR"/>
- <command name="vkAcquireNextImageKHR"/>
- <command name="vkQueuePresentKHR"/>
- </require>
- <require feature="VK_VERSION_1_1">
- <comment>This duplicates definitions in VK_KHR_device_group below</comment>
- <enum extends="VkStructureType" extnumber="61" offset="7" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"/>
- <enum extends="VkStructureType" extnumber="61" offset="8" name="VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"/>
- <enum extends="VkStructureType" extnumber="61" offset="9" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"/>
- <enum extends="VkStructureType" extnumber="61" offset="10" name="VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"/>
- <enum extends="VkStructureType" extnumber="61" offset="11" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"/>
- <enum extends="VkStructureType" extnumber="61" offset="12" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"/>
- <enum bitpos="0" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" comment="Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"/>
- <type name="VkImageSwapchainCreateInfoKHR"/>
- <type name="VkBindImageMemorySwapchainInfoKHR"/>
- <type name="VkAcquireNextImageInfoKHR"/>
- <type name="VkDeviceGroupPresentModeFlagBitsKHR"/>
- <type name="VkDeviceGroupPresentModeFlagsKHR"/>
- <type name="VkDeviceGroupPresentCapabilitiesKHR"/>
- <type name="VkDeviceGroupPresentInfoKHR"/>
- <type name="VkDeviceGroupSwapchainCreateInfoKHR"/>
- <command name="vkGetDeviceGroupPresentCapabilitiesKHR"/>
- <command name="vkGetDeviceGroupSurfacePresentModesKHR"/>
- <command name="vkGetPhysicalDevicePresentRectanglesKHR"/>
- <command name="vkAcquireNextImage2KHR"/>
- <enum bitpos="1" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR" comment="Swapchain is protected"/>
- </require>
- </extension>
- <extension name="VK_KHR_display" number="3" type="instance" requires="VK_KHR_surface" author="KHR" contact="James Jones @cubanismo,Norbert Nopper @FslNopper" supported="vulkan">
- <require>
- <enum value="23" name="VK_KHR_DISPLAY_SPEC_VERSION"/>
- <enum value=""VK_KHR_display"" name="VK_KHR_DISPLAY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_DISPLAY_KHR"/>
- <enum offset="1" extends="VkObjectType" name="VK_OBJECT_TYPE_DISPLAY_MODE_KHR"/>
- <type name="VkDisplayKHR"/>
- <type name="VkDisplayModeCreateFlagsKHR"/>
- <type name="VkDisplayModeCreateInfoKHR"/>
- <type name="VkDisplayModeKHR"/>
- <type name="VkDisplayModeParametersKHR"/>
- <type name="VkDisplayModePropertiesKHR"/>
- <type name="VkDisplayPlaneAlphaFlagBitsKHR"/>
- <type name="VkDisplayPlaneAlphaFlagsKHR"/>
- <type name="VkDisplayPlaneCapabilitiesKHR"/>
- <type name="VkDisplayPlanePropertiesKHR"/>
- <type name="VkDisplayPropertiesKHR"/>
- <type name="VkDisplaySurfaceCreateFlagsKHR"/>
- <type name="VkDisplaySurfaceCreateInfoKHR"/>
- <type name="VkSurfaceTransformFlagsKHR"/>
- <command name="vkGetPhysicalDeviceDisplayPropertiesKHR"/>
- <command name="vkGetPhysicalDeviceDisplayPlanePropertiesKHR"/>
- <command name="vkGetDisplayPlaneSupportedDisplaysKHR"/>
- <command name="vkGetDisplayModePropertiesKHR"/>
- <command name="vkCreateDisplayModeKHR"/>
- <command name="vkGetDisplayPlaneCapabilitiesKHR"/>
- <command name="vkCreateDisplayPlaneSurfaceKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_display_swapchain" number="4" type="device" requires="VK_KHR_swapchain,VK_KHR_display" author="KHR" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="10" name="VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION"/>
- <enum value=""VK_KHR_display_swapchain"" name="VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"/>
- <enum offset="1" extends="VkResult" dir="-" name="VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"/>
- <type name="VkDisplayPresentInfoKHR"/>
- <command name="vkCreateSharedSwapchainsKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_xlib_surface" number="5" type="instance" requires="VK_KHR_surface" platform="xlib" author="KHR" contact="Jesse Hall @critsec,Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="6" name="VK_KHR_XLIB_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_KHR_xlib_surface"" name="VK_KHR_XLIB_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR"/>
- <type name="VkXlibSurfaceCreateFlagsKHR"/>
- <type name="VkXlibSurfaceCreateInfoKHR"/>
- <command name="vkCreateXlibSurfaceKHR"/>
- <command name="vkGetPhysicalDeviceXlibPresentationSupportKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_xcb_surface" number="6" type="instance" requires="VK_KHR_surface" platform="xcb" author="KHR" contact="Jesse Hall @critsec,Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="6" name="VK_KHR_XCB_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_KHR_xcb_surface"" name="VK_KHR_XCB_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR"/>
- <type name="VkXcbSurfaceCreateFlagsKHR"/>
- <type name="VkXcbSurfaceCreateInfoKHR"/>
- <command name="vkCreateXcbSurfaceKHR"/>
- <command name="vkGetPhysicalDeviceXcbPresentationSupportKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_wayland_surface" number="7" type="instance" requires="VK_KHR_surface" platform="wayland" author="KHR" contact="Jesse Hall @critsec,Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="6" name="VK_KHR_WAYLAND_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_KHR_wayland_surface"" name="VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR"/>
- <type name="VkWaylandSurfaceCreateFlagsKHR"/>
- <type name="VkWaylandSurfaceCreateInfoKHR"/>
- <command name="vkCreateWaylandSurfaceKHR"/>
- <command name="vkGetPhysicalDeviceWaylandPresentationSupportKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_mir_surface" number="8" type="instance" requires="VK_KHR_surface" author="KHR" supported="disabled" comment="Extension permanently disabled. Extension number should not be reused">
- <require>
- <enum value="4" name="VK_KHR_MIR_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_KHR_mir_surface"" name="VK_KHR_MIR_SURFACE_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_android_surface" number="9" type="instance" requires="VK_KHR_surface" platform="android" author="KHR" contact="Jesse Hall @critsec" supported="vulkan">
- <require>
- <enum value="6" name="VK_KHR_ANDROID_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_KHR_android_surface"" name="VK_KHR_ANDROID_SURFACE_EXTENSION_NAME"/>
- <type name="ANativeWindow"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR"/>
- <type name="VkAndroidSurfaceCreateFlagsKHR"/>
- <type name="VkAndroidSurfaceCreateInfoKHR"/>
- <command name="vkCreateAndroidSurfaceKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_win32_surface" number="10" type="instance" requires="VK_KHR_surface" platform="win32" author="KHR" contact="Jesse Hall @critsec,Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="6" name="VK_KHR_WIN32_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_KHR_win32_surface"" name="VK_KHR_WIN32_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"/>
- <type name="VkWin32SurfaceCreateFlagsKHR"/>
- <type name="VkWin32SurfaceCreateInfoKHR"/>
- <command name="vkCreateWin32SurfaceKHR"/>
- <command name="vkGetPhysicalDeviceWin32PresentationSupportKHR"/>
- </require>
- </extension>
- <!-- TODO(liyl): spec version 8 has some types that are not supported yet. -->
- <extension name="VK_ANDROID_native_buffer" number="11" type="device" author="ANDROID" platform="android" contact="Jesse Hall @critsec" supported="vulkan">
- <require>
- <enum value="6" name="VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION"/>
- <enum value="11" name="VK_ANDROID_NATIVE_BUFFER_NUMBER"/>
- <enum value=""VK_ANDROID_native_buffer"" name="VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME"/>
- <enum name="VK_ANDROID_NATIVE_BUFFER_NAME" alias="VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"/>
- <type name="VkNativeBufferANDROID"/>
- <command name="vkGetSwapchainGrallocUsageANDROID"/>
- <command name="vkAcquireImageANDROID"/>
- <command name="vkQueueSignalReleaseImageANDROID"/>
- </require>
- </extension>
- <extension name="VK_EXT_debug_report" number="12" type="instance" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" specialuse="debugging" supported="vulkan" deprecatedby="VK_EXT_debug_utils">
- <require>
- <enum value="10" name="VK_EXT_DEBUG_REPORT_SPEC_VERSION"/>
- <enum value=""VK_EXT_debug_report"" name="VK_EXT_DEBUG_REPORT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"/>
- <enum alias="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT" comment="Backwards-compatible alias containing a typo"/>
- <enum offset="1" extends="VkResult" dir="-" name="VK_ERROR_VALIDATION_FAILED_EXT"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT"/>
- <type name="VkDebugReportCallbackEXT"/>
- <type name="PFN_vkDebugReportCallbackEXT"/>
- <type name="VkDebugReportFlagBitsEXT"/>
- <type name="VkDebugReportFlagsEXT"/>
- <type name="VkDebugReportObjectTypeEXT"/>
- <type name="VkDebugReportCallbackCreateInfoEXT"/>
- <command name="vkCreateDebugReportCallbackEXT"/>
- <command name="vkDestroyDebugReportCallbackEXT"/>
- <command name="vkDebugReportMessageEXT"/>
- </require>
- <require feature="VK_VERSION_1_1">
- <comment>This duplicates definitions in other extensions, below</comment>
- <enum extends="VkDebugReportObjectTypeEXT" extnumber="157" offset="0" name="VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT"/>
- <enum extends="VkDebugReportObjectTypeEXT" extnumber="86" offset="0" name="VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT"/>
- </require>
- </extension>
- <extension name="VK_NV_glsl_shader" number="13" type="device" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan" deprecatedby="">
- <require>
- <enum value="1" name="VK_NV_GLSL_SHADER_SPEC_VERSION"/>
- <enum value=""VK_NV_glsl_shader"" name="VK_NV_GLSL_SHADER_EXTENSION_NAME"/>
- <enum offset="0" extends="VkResult" dir="-" name="VK_ERROR_INVALID_SHADER_NV"/>
- </require>
- </extension>
- <extension name="VK_EXT_depth_range_unrestricted" type="device" number="14" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION"/>
- <enum value=""VK_EXT_depth_range_unrestricted"" name="VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_sampler_mirror_clamp_to_edge" type="device" number="15" author="KHR" contact="Tobias Hector @tobski" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="3" name="VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION"/>
- <enum value=""VK_KHR_sampler_mirror_clamp_to_edge"" name="VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME"/>
- <enum value="4" extends="VkSamplerAddressMode" name="VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" comment="Note that this defines what was previously a core enum, and so uses the 'value' attribute rather than 'offset', and does not have a suffix. This is a special case, and should not be repeated"/>
- <enum extends="VkSamplerAddressMode" name="VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR" alias="VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" comment="Alias introduced for consistency with extension suffixing rules"/>
- </require>
- </extension>
- <extension name="VK_IMG_filter_cubic" number="16" type="device" author="IMG" contact="Tobias Hector @tobski" supported="vulkan">
- <require>
- <enum value="1" name="VK_IMG_FILTER_CUBIC_SPEC_VERSION"/>
- <enum value=""VK_IMG_filter_cubic"" name="VK_IMG_FILTER_CUBIC_EXTENSION_NAME"/>
- <enum offset="0" extends="VkFilter" name="VK_FILTER_CUBIC_IMG"/>
- <enum bitpos="13" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG" comment="Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_17" number="17" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_17_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_17"" name="VK_AMD_EXTENSION_17_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_18" number="18" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_18_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_18"" name="VK_AMD_EXTENSION_18_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_rasterization_order" number="19" type="device" author="AMD" contact="Daniel Rakos @drakos-amd" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION"/>
- <enum value=""VK_AMD_rasterization_order"" name="VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"/>
- <type name="VkRasterizationOrderAMD"/>
- <type name="VkPipelineRasterizationStateRasterizationOrderAMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_20" number="20" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_20_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_20"" name="VK_AMD_EXTENSION_20_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_trinary_minmax" number="21" type="device" author="AMD" contact="Qun Lin @linqun" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_trinary_minmax"" name="VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_explicit_vertex_parameter" number="22" type="device" author="AMD" contact="Qun Lin @linqun" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_explicit_vertex_parameter"" name="VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_debug_marker" number="23" type="device" requires="VK_EXT_debug_report" author="Baldur Karlsson" contact="Baldur Karlsson @baldurk" specialuse="debugging" supported="vulkan" promotedto="VK_EXT_debug_utils">
- <require>
- <enum value="4" name="VK_EXT_DEBUG_MARKER_SPEC_VERSION"/>
- <enum value=""VK_EXT_debug_marker"" name="VK_EXT_DEBUG_MARKER_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"/>
- <type name="VkDebugReportObjectTypeEXT"/>
- <type name="VkDebugMarkerObjectNameInfoEXT"/>
- <type name="VkDebugMarkerObjectTagInfoEXT"/>
- <type name="VkDebugMarkerMarkerInfoEXT"/>
- <command name="vkDebugMarkerSetObjectTagEXT"/>
- <command name="vkDebugMarkerSetObjectNameEXT"/>
- <command name="vkCmdDebugMarkerBeginEXT"/>
- <command name="vkCmdDebugMarkerEndEXT"/>
- <command name="vkCmdDebugMarkerInsertEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_video_queue" number="24" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_sampler_ycbcr_conversion" author="KHR" contact="Tony Zlatinski @tzlatinski" provisional="true" platform="provisional" supported="vulkan">
- <require>
- <enum value="2" name="VK_KHR_VIDEO_QUEUE_SPEC_VERSION"/>
- <enum value=""VK_KHR_video_queue"" name="VK_KHR_VIDEO_QUEUE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="10" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="11" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="12" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="13" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="14" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="15" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_VIDEO_SESSION_KHR" comment="VkVideoSessionKHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkObjectType" name="VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR" comment="VkVideoSessionParametersKHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <enum offset="0" extends="VkQueryType" name="VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="4" extends="VkQueryResultFlagBits" name="VK_QUERY_RESULT_WITH_STATUS_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <type name="VkVideoSessionKHR"/>
- <type name="VkVideoSessionParametersKHR"/>
-
- <type name="VkVideoCodecOperationFlagBitsKHR"/>
- <type name="VkVideoCodecOperationFlagsKHR"/>
- <type name="VkVideoChromaSubsamplingFlagBitsKHR"/>
- <type name="VkVideoChromaSubsamplingFlagsKHR"/>
- <type name="VkVideoComponentBitDepthFlagBitsKHR"/>
- <type name="VkVideoComponentBitDepthFlagsKHR"/>
- <type name="VkVideoCapabilityFlagBitsKHR"/>
- <type name="VkVideoCapabilityFlagsKHR"/>
- <type name="VkVideoSessionCreateFlagBitsKHR"/>
- <type name="VkVideoSessionCreateFlagsKHR"/>
- <type name="VkVideoBeginCodingFlagsKHR"/>
- <type name="VkVideoEndCodingFlagsKHR"/>
- <type name="VkVideoCodingControlFlagBitsKHR"/>
- <type name="VkVideoCodingControlFlagsKHR"/>
- <type name="VkVideoCodingQualityPresetFlagBitsKHR"/>
- <type name="VkVideoCodingQualityPresetFlagsKHR"/>
-
- <type name="VkQueryResultStatusKHR"/>
-
- <type name="VkVideoQueueFamilyProperties2KHR"/>
- <type name="VkVideoProfileKHR"/>
- <type name="VkVideoProfilesKHR"/>
- <type name="VkVideoCapabilitiesKHR"/>
- <type name="VkPhysicalDeviceVideoFormatInfoKHR"/>
- <type name="VkVideoFormatPropertiesKHR"/>
- <type name="VkVideoPictureResourceKHR"/>
- <type name="VkVideoReferenceSlotKHR"/>
- <type name="VkVideoGetMemoryPropertiesKHR"/>
- <type name="VkVideoBindMemoryKHR"/>
- <type name="VkVideoSessionCreateInfoKHR"/>
- <type name="VkVideoSessionParametersCreateInfoKHR"/>
- <type name="VkVideoSessionParametersUpdateInfoKHR"/>
- <type name="VkVideoBeginCodingInfoKHR"/>
- <type name="VkVideoEndCodingInfoKHR"/>
- <type name="VkVideoCodingControlInfoKHR"/>
-
- <command name="vkGetPhysicalDeviceVideoCapabilitiesKHR"/>
- <command name="vkGetPhysicalDeviceVideoFormatPropertiesKHR"/>
-
- <command name="vkCreateVideoSessionKHR"/>
- <command name="vkDestroyVideoSessionKHR"/>
- <command name="vkGetVideoSessionMemoryRequirementsKHR"/>
- <command name="vkBindVideoSessionMemoryKHR"/>
- <command name="vkCreateVideoSessionParametersKHR"/>
- <command name="vkUpdateVideoSessionParametersKHR"/>
- <command name="vkDestroyVideoSessionParametersKHR"/>
- <command name="vkCmdBeginVideoCodingKHR"/>
- <command name="vkCmdEndVideoCodingKHR"/>
- <command name="vkCmdControlVideoCodingKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_video_decode_queue" number="25" type="device" requires="VK_KHR_video_queue,VK_KHR_synchronization2" author="KHR" contact="[email protected]" provisional="true" platform="provisional" supported="vulkan">
- <require>
- <enum value="2" name="VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION"/>
- <enum value=""VK_KHR_video_decode_queue"" name="VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="5" extends="VkQueueFlagBits" name="VK_QUEUE_VIDEO_DECODE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="26" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="35" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS" />
- <enum bitpos="36" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="13" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="14" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="10" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="11" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="12" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="25" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="26" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="0" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="2" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <type name="VkVideoDecodeFlagBitsKHR"/>
- <type name="VkVideoDecodeFlagsKHR"/>
-
- <type name="VkVideoDecodeInfoKHR"/>
- <command name="vkCmdDecodeVideoKHR"/>
- </require>
- <require extension="VK_KHR_format_feature_flags2">
- <enum bitpos="25" extends="VkFormatFeatureFlagBits2KHR" name="VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="26" extends="VkFormatFeatureFlagBits2KHR" name="VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- </require>
- </extension>
- <extension name="VK_AMD_gcn_shader" number="26" type="device" author="AMD" contact="Dominik Witczak @dominikwitczakamd" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_GCN_SHADER_SPEC_VERSION"/>
- <enum value=""VK_AMD_gcn_shader"" name="VK_AMD_GCN_SHADER_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_dedicated_allocation" number="27" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan" deprecatedby="VK_KHR_dedicated_allocation">
- <require>
- <enum value="1" name="VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION"/>
- <enum value=""VK_NV_dedicated_allocation"" name="VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"/>
- <type name="VkDedicatedAllocationImageCreateInfoNV"/>
- <type name="VkDedicatedAllocationBufferCreateInfoNV"/>
- <type name="VkDedicatedAllocationMemoryAllocateInfoNV"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_28" number="28" author="NV" contact="Piers Daniell @pdaniell-nv" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_28_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_28"" name="VK_EXT_EXTENSION_28_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_transform_feedback" number="29" type="device" author="NV" contact="Piers Daniell @pdaniell-nv" specialuse="glemulation,d3demulation,devtools" supported="vulkan" requires="VK_KHR_get_physical_device_properties2">
- <require>
- <enum value="1" name="VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION"/>
- <enum value=""VK_EXT_transform_feedback"" name="VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME"/>
- <command name="vkCmdBindTransformFeedbackBuffersEXT"/>
- <command name="vkCmdBeginTransformFeedbackEXT"/>
- <command name="vkCmdEndTransformFeedbackEXT"/>
- <command name="vkCmdBeginQueryIndexedEXT"/>
- <command name="vkCmdEndQueryIndexedEXT"/>
- <command name="vkCmdDrawIndirectByteCountEXT"/>
-
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"/>
-
- <enum offset="4" extends="VkQueryType" name="VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT"/>
-
- <enum bitpos="11" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"/>
- <enum bitpos="12" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"/>
-
- <enum bitpos="25" extends="VkAccessFlagBits" name="VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"/>
- <enum bitpos="26" extends="VkAccessFlagBits" name="VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"/>
- <enum bitpos="27" extends="VkAccessFlagBits" name="VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"/>
-
- <enum bitpos="24" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT"/>
-
- <type name="VkPhysicalDeviceTransformFeedbackFeaturesEXT"/>
- <type name="VkPhysicalDeviceTransformFeedbackPropertiesEXT"/>
- <type name="VkPipelineRasterizationStateStreamCreateInfoEXT"/>
-
- <type name="VkPipelineRasterizationStateStreamCreateFlagsEXT"/>
- </require>
- </extension>
- <extension name="VK_NVX_binary_import" number="30" type="device" author="NVX" contact="Eric Werness @ewerness-nv,Liam Middlebrook @liam-middlebrook" supported="vulkan">
- <require>
- <enum value="1" name="VK_NVX_BINARY_IMPORT_SPEC_VERSION"/>
- <enum value=""VK_NVX_binary_import"" name="VK_NVX_BINARY_IMPORT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_CU_MODULE_NVX"/>
- <enum offset="1" extends="VkObjectType" name="VK_OBJECT_TYPE_CU_FUNCTION_NVX"/>
- <enum offset="0" extends="VkDebugReportObjectTypeEXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT"/>
- <enum offset="1" extends="VkDebugReportObjectTypeEXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT"/>
- <type name="VkCuModuleNVX"/>
- <type name="VkCuFunctionNVX"/>
- <type name="VkCuModuleCreateInfoNVX"/>
- <type name="VkCuFunctionCreateInfoNVX"/>
- <type name="VkCuLaunchInfoNVX"/>
- <command name="vkCreateCuModuleNVX"/>
- <command name="vkCreateCuFunctionNVX"/>
- <command name="vkDestroyCuModuleNVX"/>
- <command name="vkDestroyCuFunctionNVX"/>
- <command name="vkCmdCuLaunchKernelNVX"/>
- </require>
- </extension>
- <extension name="VK_NVX_image_view_handle" number="31" type="device" author="NVX" contact="Eric Werness @ewerness-nv" supported="vulkan">
- <require>
- <enum value="2" name="VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION"/>
- <enum value=""VK_NVX_image_view_handle"" name="VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"/>
- <type name="VkImageViewHandleInfoNVX"/>
- <type name="VkImageViewAddressPropertiesNVX"/>
- <command name="vkGetImageViewHandleNVX"/>
- <command name="vkGetImageViewAddressNVX"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_32" number="32" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_32_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_32"" name="VK_AMD_EXTENSION_32_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_33" number="33" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_33_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_33"" name="VK_AMD_EXTENSION_33_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_draw_indirect_count" number="34" type="device" author="AMD" contact="Daniel Rakos @drakos-amd" supported="vulkan" promotedto="VK_KHR_draw_indirect_count">
- <require>
- <enum value="2" name="VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION"/>
- <enum value=""VK_AMD_draw_indirect_count"" name="VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME"/>
- <command name="vkCmdDrawIndirectCountAMD"/>
- <command name="vkCmdDrawIndexedIndirectCountAMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_35" number="35" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_35_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_35"" name="VK_AMD_EXTENSION_35_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_negative_viewport_height" number="36" type="device" author="AMD" contact="Matthaeus G. Chajdas @anteru" supported="vulkan" obsoletedby="VK_KHR_maintenance1">
- <require>
- <enum value="1" name="VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION"/>
- <enum value=""VK_AMD_negative_viewport_height"" name="VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_gpu_shader_half_float" number="37" type="device" author="AMD" contact="Dominik Witczak @dominikwitczakamd" supported="vulkan" deprecatedby="VK_KHR_shader_float16_int8">
- <require>
- <enum value="2" name="VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION"/>
- <enum value=""VK_AMD_gpu_shader_half_float"" name="VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_ballot" number="38" type="device" author="AMD" contact="Dominik Witczak @dominikwitczakamd" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_SHADER_BALLOT_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_ballot"" name="VK_AMD_SHADER_BALLOT_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_video_encode_h264" number="39" type="device" requires="VK_KHR_video_encode_queue" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" provisional="true" platform="provisional" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION"/>
- <enum value=""VK_EXT_video_encode_h264"" name="VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="16" extends="VkVideoCodecOperationFlagBitsKHR" name="VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <type name="VkVideoEncodeH264CapabilityFlagBitsEXT"/>
- <type name="VkVideoEncodeH264CapabilityFlagsEXT"/>
- <type name="VkVideoEncodeH264InputModeFlagBitsEXT"/>
- <type name="VkVideoEncodeH264InputModeFlagsEXT"/>
- <type name="VkVideoEncodeH264OutputModeFlagBitsEXT"/>
- <type name="VkVideoEncodeH264OutputModeFlagsEXT"/>
- <type name="VkVideoEncodeH264CreateFlagBitsEXT"/>
- <type name="VkVideoEncodeH264CreateFlagsEXT"/>
- <type name="VkVideoEncodeH264CapabilitiesEXT"/>
- <type name="VkVideoEncodeH264SessionCreateInfoEXT"/>
- <type name="VkVideoEncodeH264SessionParametersCreateInfoEXT"/>
- <type name="VkVideoEncodeH264SessionParametersAddInfoEXT"/>
- <type name="VkVideoEncodeH264VclFrameInfoEXT"/>
- <type name="VkVideoEncodeH264EmitPictureParametersEXT"/>
- <type name="VkVideoEncodeH264DpbSlotInfoEXT"/>
- <type name="VkVideoEncodeH264NaluSliceEXT"/>
- <type name="VkVideoEncodeH264ProfileEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_video_encode_h265" number="40" type="device" requires="VK_KHR_video_encode_queue" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" provisional="true" platform="provisional" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION"/>
- <enum value=""VK_EXT_video_encode_h265"" name="VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="17" extends="VkVideoCodecOperationFlagBitsKHR" name="VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <type name="VkVideoEncodeH265CapabilityFlagsEXT"/>
- <type name="VkVideoEncodeH265InputModeFlagBitsEXT"/>
- <type name="VkVideoEncodeH265InputModeFlagsEXT"/>
- <type name="VkVideoEncodeH265OutputModeFlagBitsEXT"/>
- <type name="VkVideoEncodeH265OutputModeFlagsEXT"/>
- <type name="VkVideoEncodeH265CreateFlagsEXT" comment="Will add VkVideoEncodeH265CreateFlagBitsEXT when bits are defined in the future"/>
-
- <type name="VkVideoEncodeH265CtbSizeFlagBitsEXT"/>
- <type name="VkVideoEncodeH265CtbSizeFlagsEXT"/>
- <type name="VkVideoEncodeH265CapabilitiesEXT"/>
- <type name="VkVideoEncodeH265SessionCreateInfoEXT"/>
- <type name="VkVideoEncodeH265SessionParametersCreateInfoEXT"/>
- <type name="VkVideoEncodeH265SessionParametersAddInfoEXT"/>
- <type name="VkVideoEncodeH265VclFrameInfoEXT"/>
- <type name="VkVideoEncodeH265EmitPictureParametersEXT"/>
- <type name="VkVideoEncodeH265DpbSlotInfoEXT"/>
- <type name="VkVideoEncodeH265NaluSliceEXT"/>
- <type name="VkVideoEncodeH265ProfileEXT"/>
- <type name="VkVideoEncodeH265ReferenceListsEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_video_decode_h264" number="41" type="device" requires="VK_KHR_video_decode_queue" author="KHR" contact="[email protected]" provisional="true" platform="provisional" supported="vulkan">
- <require>
- <enum value="3" name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
- <enum value=""VK_EXT_video_decode_h264"" name="VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="0" extends="VkVideoCodecOperationFlagBitsKHR" name="VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <type name="VkVideoDecodeH264PictureLayoutFlagBitsEXT"/>
- <type name="VkVideoDecodeH264PictureLayoutFlagsEXT"/>
- <type name="VkVideoDecodeH264CreateFlagsEXT"/>
- <type name="VkVideoDecodeH264ProfileEXT"/>
- <type name="VkVideoDecodeH264CapabilitiesEXT"/>
- <type name="VkVideoDecodeH264SessionCreateInfoEXT"/>
- <type name="VkVideoDecodeH264SessionParametersCreateInfoEXT"/>
- <type name="VkVideoDecodeH264SessionParametersAddInfoEXT"/>
- <type name="VkVideoDecodeH264PictureInfoEXT"/>
- <type name="VkVideoDecodeH264MvcEXT"/>
- <type name="VkVideoDecodeH264DpbSlotInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_AMD_texture_gather_bias_lod" number="42" author="AMD" contact="Rex Xu @amdrexu" supported="vulkan" type="device" requires="VK_KHR_get_physical_device_properties2">
- <require>
- <enum value="1" name="VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION"/>
- <enum value=""VK_AMD_texture_gather_bias_lod"" name="VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"/>
- <type name="VkTextureLODGatherFormatPropertiesAMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_info" number="43" author="AMD" contact="Jaakko Konttinen @jaakkoamd" supported="vulkan" specialuse="devtools" type="device">
- <require>
- <enum value="1" name="VK_AMD_SHADER_INFO_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_info"" name="VK_AMD_SHADER_INFO_EXTENSION_NAME"/>
- <type name="VkShaderInfoTypeAMD"/>
- <type name="VkShaderResourceUsageAMD"/>
- <type name="VkShaderStatisticsInfoAMD"/>
- <command name="vkGetShaderInfoAMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_44" number="44" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_44_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_44"" name="VK_AMD_EXTENSION_44_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_dynamic_rendering" number="45" author="KHR" type="device" requires="VK_KHR_get_physical_device_properties2" contact="Tobias Hector @tobski" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION"/>
- <enum value=""VK_KHR_dynamic_rendering"" name="VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME"/>
- <command name="vkCmdBeginRenderingKHR"/>
- <command name="vkCmdEndRenderingKHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDERING_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR"/>
- <enum offset="0" extends="VkAttachmentStoreOp" extnumber="302" name="VK_ATTACHMENT_STORE_OP_NONE_KHR"/>
- <type name="VkRenderingInfoKHR"/>
- <type name="VkRenderingAttachmentInfoKHR"/>
- <type name="VkPipelineRenderingCreateInfoKHR"/>
- <type name="VkPhysicalDeviceDynamicRenderingFeaturesKHR"/>
- <type name="VkCommandBufferInheritanceRenderingInfoKHR"/>
- <type name="VkRenderingFlagsKHR"/>
- <type name="VkRenderingFlagBitsKHR"/>
- </require>
- <require extension="VK_KHR_fragment_shading_rate">
- <enum bitpos="21" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"/>
- <type name="VkRenderingFragmentShadingRateAttachmentInfoKHR"/>
- </require>
- <require extension="VK_EXT_fragment_density_map">
- <enum bitpos="22" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"/>
- <type name="VkRenderingFragmentDensityMapAttachmentInfoEXT"/>
- </require>
- <require extension="VK_AMD_mixed_attachment_samples">
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"/>
- <type name="VkAttachmentSampleCountInfoAMD"/>
- </require>
- <require extension="VK_NV_framebuffer_mixed_samples">
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV" alias="VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"/>
- <type name="VkAttachmentSampleCountInfoNV"/>
- </require>
- <require extension="VK_NVX_multiview_per_view_attributes">
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"/>
- <type name="VkMultiviewPerViewAttributesInfoNVX"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_46" number="46" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_46_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_46"" name="VK_AMD_EXTENSION_46_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_image_load_store_lod" number="47" author="AMD" contact="Dominik Witczak @dominikwitczakamd" supported="vulkan" type="device">
- <require>
- <enum value="1" name="VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_image_load_store_lod"" name="VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NVX_extension_48" number="48" author="NVX" contact="James Jones @cubanismo" supported="disabled">
- <require>
- <enum value="0" name="VK_NVX_EXTENSION_48_SPEC_VERSION"/>
- <enum value=""VK_NVX_extension_48"" name="VK_NVX_EXTENSION_48_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_extension_49" number="49" author="GOOGLE" contact="Jean-Francois Roy @jfroy" supported="disabled">
- <require>
- <enum value="0" name="VK_GOOGLE_EXTENSION_49_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_extension_49"" name="VK_GOOGLE_EXTENSION_49_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GGP_stream_descriptor_surface" number="50" type="instance" requires="VK_KHR_surface" platform="ggp" author="GGP" contact="Jean-Francois Roy @jfroy" supported="vulkan">
- <require>
- <enum value="1" name="VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_GGP_stream_descriptor_surface"" name="VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"/>
- <type name="VkStreamDescriptorSurfaceCreateFlagsGGP"/>
- <type name="VkStreamDescriptorSurfaceCreateInfoGGP"/>
- <command name="vkCreateStreamDescriptorSurfaceGGP"/>
- </require>
- </extension>
- <extension name="VK_NV_corner_sampled_image" number="51" author="NV" type="device" requires="VK_KHR_get_physical_device_properties2" contact="Daniel Koch @dgkoch" supported="vulkan">
- <require>
- <enum value="2" name="VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION"/>
- <enum value=""VK_NV_corner_sampled_image"" name="VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME"/>
- <enum bitpos="13" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"/>
- <type name="VkPhysicalDeviceCornerSampledImageFeaturesNV"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_52" number="52" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_52_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_52"" name="VK_NV_EXTENSION_52_EXTENSION_NAME"/>
- <enum bitpos="0" extends="VkShaderModuleCreateFlagBits" name="VK_SHADER_MODULE_CREATE_RESERVED_0_BIT_NV"/>
- <enum bitpos="2" extends="VkPipelineShaderStageCreateFlagBits" name="VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_2_BIT_NV"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_53" number="53" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_53_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_53"" name="VK_NV_EXTENSION_53_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_multiview" number="54" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_MULTIVIEW_SPEC_VERSION"/>
- <enum value=""VK_KHR_multiview"" name="VK_KHR_MULTIVIEW_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"/>
- <enum extends="VkDependencyFlagBits" name="VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR" alias="VK_DEPENDENCY_VIEW_LOCAL_BIT"/>
- <type name="VkRenderPassMultiviewCreateInfoKHR"/>
- <type name="VkPhysicalDeviceMultiviewFeaturesKHR"/>
- <type name="VkPhysicalDeviceMultiviewPropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_IMG_format_pvrtc" number="55" type="device" author="IMG" contact="Stuart Smith" supported="vulkan">
- <require>
- <enum value="1" name="VK_IMG_FORMAT_PVRTC_SPEC_VERSION"/>
- <enum value=""VK_IMG_format_pvrtc"" name="VK_IMG_FORMAT_PVRTC_EXTENSION_NAME"/>
- <enum offset="0" extends="VkFormat" name="VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"/>
- <enum offset="1" extends="VkFormat" name="VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"/>
- <enum offset="2" extends="VkFormat" name="VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"/>
- <enum offset="3" extends="VkFormat" name="VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"/>
- <enum offset="4" extends="VkFormat" name="VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"/>
- <enum offset="5" extends="VkFormat" name="VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"/>
- <enum offset="6" extends="VkFormat" name="VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"/>
- <enum offset="7" extends="VkFormat" name="VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"/>
- </require>
- </extension>
- <extension name="VK_NV_external_memory_capabilities" number="56" type="instance" author="NV" contact="James Jones @cubanismo" supported="vulkan" deprecatedby="VK_KHR_external_memory_capabilities">
- <require>
- <enum value="1" name="VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION"/>
- <enum value=""VK_NV_external_memory_capabilities"" name="VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME"/>
- <type name="VkExternalMemoryHandleTypeFlagsNV"/>
- <type name="VkExternalMemoryHandleTypeFlagBitsNV"/>
- <type name="VkExternalMemoryFeatureFlagsNV"/>
- <type name="VkExternalMemoryFeatureFlagBitsNV"/>
- <type name="VkExternalImageFormatPropertiesNV"/>
- <command name="vkGetPhysicalDeviceExternalImageFormatPropertiesNV"/>
- </require>
- </extension>
- <extension name="VK_NV_external_memory" number="57" type="device" requires="VK_NV_external_memory_capabilities" author="NV" contact="James Jones @cubanismo" supported="vulkan" deprecatedby="VK_KHR_external_memory">
- <require>
- <enum value="1" name="VK_NV_EXTERNAL_MEMORY_SPEC_VERSION"/>
- <enum value=""VK_NV_external_memory"" name="VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV"/>
- <type name="VkExternalMemoryImageCreateInfoNV"/>
- <type name="VkExportMemoryAllocateInfoNV"/>
- </require>
- </extension>
- <extension name="VK_NV_external_memory_win32" number="58" type="device" requires="VK_NV_external_memory" author="NV" contact="James Jones @cubanismo" platform="win32" supported="vulkan" deprecatedby="VK_KHR_external_memory_win32">
- <require>
- <enum value="1" name="VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION"/>
- <enum value=""VK_NV_external_memory_win32"" name="VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"/>
- <type name="VkImportMemoryWin32HandleInfoNV"/>
- <type name="VkExportMemoryWin32HandleInfoNV"/>
- <command name="vkGetMemoryWin32HandleNV"/>
- </require>
- </extension>
- <extension name="VK_NV_win32_keyed_mutex" number="59" type="device" requires="VK_NV_external_memory_win32" author="NV" contact="Carsten Rohde @crohde" platform="win32" supported="vulkan" promotedto="VK_KHR_win32_keyed_mutex">
- <require>
- <enum value="2" name="VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION"/>
- <enum value=""VK_NV_win32_keyed_mutex"" name="VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"/>
- <type name="VkWin32KeyedMutexAcquireReleaseInfoNV"/>
- </require>
- </extension>
- <extension name="VK_KHR_get_physical_device_properties2" number="60" type="instance" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="2" name="VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_get_physical_device_properties2"" name="VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR" alias="VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR" alias="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR" alias="VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR" alias="VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2"/>
- <type name="VkPhysicalDeviceFeatures2KHR"/>
- <type name="VkPhysicalDeviceProperties2KHR"/>
- <type name="VkFormatProperties2KHR"/>
- <type name="VkImageFormatProperties2KHR"/>
- <type name="VkPhysicalDeviceImageFormatInfo2KHR"/>
- <type name="VkQueueFamilyProperties2KHR"/>
- <type name="VkPhysicalDeviceMemoryProperties2KHR"/>
- <type name="VkSparseImageFormatProperties2KHR"/>
- <type name="VkPhysicalDeviceSparseImageFormatInfo2KHR"/>
- <command name="vkGetPhysicalDeviceFeatures2KHR"/>
- <command name="vkGetPhysicalDeviceProperties2KHR"/>
- <command name="vkGetPhysicalDeviceFormatProperties2KHR"/>
- <command name="vkGetPhysicalDeviceImageFormatProperties2KHR"/>
- <command name="vkGetPhysicalDeviceQueueFamilyProperties2KHR"/>
- <command name="vkGetPhysicalDeviceMemoryProperties2KHR"/>
- <command name="vkGetPhysicalDeviceSparseImageFormatProperties2KHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_device_group" number="61" type="device" author="KHR" requires="VK_KHR_device_group_creation" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="4" name="VK_KHR_DEVICE_GROUP_SPEC_VERSION"/>
- <enum value=""VK_KHR_device_group"" name="VK_KHR_DEVICE_GROUP_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR" alias="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR" alias="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR" alias="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR" alias="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR" alias="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO"/>
- <type name="VkPeerMemoryFeatureFlagsKHR"/>
- <type name="VkPeerMemoryFeatureFlagBitsKHR"/>
- <enum extends="VkPeerMemoryFeatureFlagBits" name="VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR" alias="VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"/>
- <enum extends="VkPeerMemoryFeatureFlagBits" name="VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR" alias="VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"/>
- <enum extends="VkPeerMemoryFeatureFlagBits" name="VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR" alias="VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"/>
- <enum extends="VkPeerMemoryFeatureFlagBits" name="VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR" alias="VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"/>
- <type name="VkMemoryAllocateFlagsKHR"/>
- <type name="VkMemoryAllocateFlagBitsKHR"/>
- <enum extends="VkMemoryAllocateFlagBits" name="VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR" alias="VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"/>
- <type name="VkMemoryAllocateFlagsInfoKHR"/>
- <type name="VkDeviceGroupRenderPassBeginInfoKHR"/>
- <type name="VkDeviceGroupCommandBufferBeginInfoKHR"/>
- <type name="VkDeviceGroupSubmitInfoKHR"/>
- <type name="VkDeviceGroupBindSparseInfoKHR"/>
- <command name="vkGetDeviceGroupPeerMemoryFeaturesKHR"/>
- <command name="vkCmdSetDeviceMaskKHR"/>
- <command name="vkCmdDispatchBaseKHR"/>
- <enum extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR" alias="VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"/>
- <enum extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_DISPATCH_BASE_KHR" alias="VK_PIPELINE_CREATE_DISPATCH_BASE"/>
- <enum extends="VkDependencyFlagBits" name="VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR" alias="VK_DEPENDENCY_DEVICE_GROUP_BIT"/>
- </require>
- <require extension="VK_KHR_bind_memory2">
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR" alias="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR" alias="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"/>
- <type name="VkBindBufferMemoryDeviceGroupInfoKHR"/>
- <type name="VkBindImageMemoryDeviceGroupInfoKHR"/>
- <enum extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" alias="VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"/>
- </require>
- <require extension="VK_KHR_surface">
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"/>
- <type name="VkDeviceGroupPresentModeFlagBitsKHR"/>
- <type name="VkDeviceGroupPresentModeFlagsKHR"/>
- <type name="VkDeviceGroupPresentCapabilitiesKHR"/>
- <command name="vkGetDeviceGroupPresentCapabilitiesKHR"/>
- <command name="vkGetDeviceGroupSurfacePresentModesKHR"/>
- <command name="vkGetPhysicalDevicePresentRectanglesKHR"/>
- </require>
- <require extension="VK_KHR_swapchain">
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"/>
- <enum offset="10" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"/>
- <enum offset="11" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"/>
- <enum offset="12" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"/>
- <enum bitpos="0" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" comment="Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"/>
- <type name="VkImageSwapchainCreateInfoKHR"/>
- <type name="VkBindImageMemorySwapchainInfoKHR"/>
- <type name="VkAcquireNextImageInfoKHR"/>
- <type name="VkDeviceGroupPresentInfoKHR"/>
- <type name="VkDeviceGroupSwapchainCreateInfoKHR"/>
- <command name="vkAcquireNextImage2KHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_validation_flags" number="62" type="instance" author="GOOGLE" contact="Tobin Ehlis @tobine" specialuse="debugging" supported="vulkan" deprecatedby="VK_EXT_validation_features">
- <require>
- <enum value="2" name="VK_EXT_VALIDATION_FLAGS_SPEC_VERSION"/>
- <enum value=""VK_EXT_validation_flags"" name="VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT"/>
- <type name="VkValidationFlagsEXT"/>
- <type name="VkValidationCheckEXT"/>
- </require>
- </extension>
- <extension name="VK_NN_vi_surface" number="63" type="instance" author="NN" contact="Mathias Heyer gitlab:@mheyer" requires="VK_KHR_surface" platform="vi" supported="vulkan">
- <require>
- <enum value="1" name="VK_NN_VI_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_NN_vi_surface"" name="VK_NN_VI_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN"/>
- <type name="VkViSurfaceCreateFlagsNN"/>
- <type name="VkViSurfaceCreateInfoNN"/>
- <command name="vkCreateViSurfaceNN"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_draw_parameters" number="64" type="device" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_draw_parameters"" name="VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_subgroup_ballot" number="65" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan" deprecatedby="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_subgroup_ballot"" name="VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_subgroup_vote" number="66" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan" deprecatedby="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_subgroup_vote"" name="VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_texture_compression_astc_hdr" number="67" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" requires="VK_KHR_get_physical_device_properties2" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION"/>
- <enum value=""VK_EXT_texture_compression_astc_hdr"" name="VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT"/>
- <enum extends="VkFormat" extnumber="67" offset="0" name="VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="1" name="VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="2" name="VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="3" name="VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="4" name="VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="5" name="VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="6" name="VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="7" name="VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="8" name="VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="9" name="VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="10" name="VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="11" name="VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="12" name="VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="67" offset="13" name="VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_astc_decode_mode" number="68" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" requires="VK_KHR_get_physical_device_properties2" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION"/>
- <enum value=""VK_EXT_astc_decode_mode"" name="VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"/>
- <type name="VkImageViewASTCDecodeModeEXT"/>
- <type name="VkPhysicalDeviceASTCDecodeFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_IMG_extension_69" number="69" type="device" author="IMG" contact="Tobias Hector @tobski" supported="disabled">
- <require>
- <enum value="0" name="VK_IMG_EXTENSION_69_SPEC_VERSION"/>
- <enum value=""VK_IMG_extension_69"" name="VK_IMG_EXTENSION_69_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_maintenance1" number="70" type="device" author="KHR" contact="Piers Daniell @pdaniell-nv" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="2" name="VK_KHR_MAINTENANCE_1_SPEC_VERSION"/>
- <enum value=""VK_KHR_maintenance1"" name="VK_KHR_MAINTENANCE_1_EXTENSION_NAME"/>
- <enum alias="VK_KHR_MAINTENANCE_1_SPEC_VERSION" name="VK_KHR_MAINTENANCE1_SPEC_VERSION" comment="Backwards-compatible alias containing a typo"/>
- <enum alias="VK_KHR_MAINTENANCE_1_EXTENSION_NAME" name="VK_KHR_MAINTENANCE1_EXTENSION_NAME" comment="Backwards-compatible alias containing a typo"/>
- <enum extends="VkResult" name="VK_ERROR_OUT_OF_POOL_MEMORY_KHR" alias="VK_ERROR_OUT_OF_POOL_MEMORY"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR" alias="VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR" alias="VK_FORMAT_FEATURE_TRANSFER_DST_BIT"/>
- <enum extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR" alias="VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"/>
- <type name="VkCommandPoolTrimFlagsKHR"/>
- <command name="vkTrimCommandPoolKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_device_group_creation" number="71" type="instance" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION"/>
- <enum value=""VK_KHR_device_group_creation"" name="VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"/>
- <enum name="VK_MAX_DEVICE_GROUP_SIZE_KHR"/>
- <type name="VkPhysicalDeviceGroupPropertiesKHR"/>
- <type name="VkDeviceGroupDeviceCreateInfoKHR"/>
- <command name="vkEnumeratePhysicalDeviceGroupsKHR"/>
- <enum extends="VkMemoryHeapFlagBits" name="VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR" alias="VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_memory_capabilities" number="72" type="instance" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_memory_capabilities"" name="VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"/>
- <enum name="VK_LUID_SIZE_KHR"/>
- <type name="VkExternalMemoryHandleTypeFlagsKHR"/>
- <type name="VkExternalMemoryHandleTypeFlagBitsKHR"/>
- <enum extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR" alias="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"/>
- <enum extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR" alias="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"/>
- <enum extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR" alias="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"/>
- <enum extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR" alias="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"/>
- <enum extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR" alias="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"/>
- <enum extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR" alias="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"/>
- <enum extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR" alias="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"/>
- <type name="VkExternalMemoryFeatureFlagsKHR"/>
- <type name="VkExternalMemoryFeatureFlagBitsKHR"/>
- <enum extends="VkExternalMemoryFeatureFlagBits" name="VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR" alias="VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"/>
- <enum extends="VkExternalMemoryFeatureFlagBits" name="VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR" alias="VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"/>
- <enum extends="VkExternalMemoryFeatureFlagBits" name="VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR" alias="VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"/>
- <type name="VkExternalMemoryPropertiesKHR"/>
- <type name="VkPhysicalDeviceExternalImageFormatInfoKHR"/>
- <type name="VkExternalImageFormatPropertiesKHR"/>
- <type name="VkPhysicalDeviceExternalBufferInfoKHR"/>
- <type name="VkExternalBufferPropertiesKHR"/>
- <type name="VkPhysicalDeviceIDPropertiesKHR"/>
- <command name="vkGetPhysicalDeviceExternalBufferPropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_memory" number="73" type="device" requires="VK_KHR_external_memory_capabilities" author="KHR" contact="James Jones @cubanismo" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_memory"" name="VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"/>
- <enum extends="VkResult" name="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR" alias="VK_ERROR_INVALID_EXTERNAL_HANDLE"/>
- <enum name="VK_QUEUE_FAMILY_EXTERNAL_KHR"/>
- <type name="VkExternalMemoryImageCreateInfoKHR"/>
- <type name="VkExternalMemoryBufferCreateInfoKHR"/>
- <type name="VkExportMemoryAllocateInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_memory_win32" number="74" type="device" requires="VK_KHR_external_memory" author="KHR" contact="James Jones @cubanismo" platform="win32" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_memory_win32"" name="VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"/>
- <type name="VkImportMemoryWin32HandleInfoKHR"/>
- <type name="VkExportMemoryWin32HandleInfoKHR"/>
- <type name="VkMemoryWin32HandlePropertiesKHR"/>
- <type name="VkMemoryGetWin32HandleInfoKHR"/>
- <command name="vkGetMemoryWin32HandleKHR"/>
- <command name="vkGetMemoryWin32HandlePropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_memory_fd" number="75" type="device" requires="VK_KHR_external_memory" author="KHR" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_memory_fd"" name="VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"/>
- <type name="VkImportMemoryFdInfoKHR"/>
- <type name="VkMemoryFdPropertiesKHR"/>
- <type name="VkMemoryGetFdInfoKHR"/>
- <command name="vkGetMemoryFdKHR"/>
- <command name="vkGetMemoryFdPropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_win32_keyed_mutex" number="76" type="device" requires="VK_KHR_external_memory_win32" author="KHR" contact="Carsten Rohde @crohde" platform="win32" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION"/>
- <enum value=""VK_KHR_win32_keyed_mutex"" name="VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"/>
- <type name="VkWin32KeyedMutexAcquireReleaseInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_semaphore_capabilities" number="77" type="instance" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_semaphore_capabilities"" name="VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"/>
- <enum name="VK_LUID_SIZE_KHR"/>
- <type name="VkExternalSemaphoreHandleTypeFlagsKHR"/>
- <type name="VkExternalSemaphoreHandleTypeFlagBitsKHR"/>
- <enum extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR" alias="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"/>
- <enum extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR" alias="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"/>
- <enum extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR" alias="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"/>
- <enum extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR" alias="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"/>
- <enum extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR" alias="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"/>
- <type name="VkExternalSemaphoreFeatureFlagsKHR"/>
- <type name="VkExternalSemaphoreFeatureFlagBitsKHR"/>
- <enum extends="VkExternalSemaphoreFeatureFlagBits" name="VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR" alias="VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"/>
- <enum extends="VkExternalSemaphoreFeatureFlagBits" name="VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR" alias="VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"/>
- <type name="VkPhysicalDeviceExternalSemaphoreInfoKHR"/>
- <type name="VkExternalSemaphorePropertiesKHR"/>
- <type name="VkPhysicalDeviceIDPropertiesKHR"/>
- <command name="vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_semaphore" number="78" type="device" requires="VK_KHR_external_semaphore_capabilities" author="KHR" contact="James Jones @cubanismo" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_semaphore"" name="VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"/>
- <type name="VkSemaphoreImportFlagsKHR"/>
- <type name="VkSemaphoreImportFlagBitsKHR"/>
- <enum extends="VkSemaphoreImportFlagBits" name="VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR" alias="VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"/>
- <type name="VkExportSemaphoreCreateInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_semaphore_win32" number="79" type="device" requires="VK_KHR_external_semaphore" author="KHR" contact="James Jones @cubanismo" platform="win32" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_semaphore_win32"" name="VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"/>
- <type name="VkImportSemaphoreWin32HandleInfoKHR"/>
- <type name="VkExportSemaphoreWin32HandleInfoKHR"/>
- <type name="VkD3D12FenceSubmitInfoKHR"/>
- <type name="VkSemaphoreGetWin32HandleInfoKHR"/>
- <command name="vkImportSemaphoreWin32HandleKHR"/>
- <command name="vkGetSemaphoreWin32HandleKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_semaphore_fd" number="80" type="device" requires="VK_KHR_external_semaphore" author="KHR" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_semaphore_fd"" name="VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"/>
- <type name="VkImportSemaphoreFdInfoKHR"/>
- <type name="VkSemaphoreGetFdInfoKHR"/>
- <command name="vkImportSemaphoreFdKHR"/>
- <command name="vkGetSemaphoreFdKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_push_descriptor" number="81" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="2" name="VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION"/>
- <enum value=""VK_KHR_push_descriptor"" name="VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"/>
- <enum bitpos="0" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" comment="Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"/>
- <command name="vkCmdPushDescriptorSetKHR"/>
- <type name="VkPhysicalDevicePushDescriptorPropertiesKHR"/>
- </require>
- <require feature="VK_VERSION_1_1">
- <command name="vkCmdPushDescriptorSetWithTemplateKHR"/>
- <enum value="1" extends="VkDescriptorUpdateTemplateType" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR" comment="Create descriptor update template for pushed descriptor updates"/>
- </require>
- <require extension="VK_KHR_descriptor_update_template">
- <command name="vkCmdPushDescriptorSetWithTemplateKHR"/>
- <enum value="1" extends="VkDescriptorUpdateTemplateType" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR" comment="Create descriptor update template for pushed descriptor updates"/>
- </require>
- </extension>
- <extension name="VK_EXT_conditional_rendering" number="82" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION"/>
- <enum value=""VK_EXT_conditional_rendering"" name="VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT"/>
- <type name="VkConditionalRenderingFlagsEXT"/>
- <type name="VkConditionalRenderingFlagBitsEXT"/>
- <enum bitpos="20" extends="VkAccessFlagBits" name="VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT" comment="read access flag for reading conditional rendering predicate"/>
- <enum bitpos="9" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT" comment="Specifies the buffer can be used as predicate in conditional rendering"/>
- <enum bitpos="18" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" comment="A pipeline stage for conditional rendering predicate fetch"/>
- <command name="vkCmdBeginConditionalRenderingEXT"/>
- <command name="vkCmdEndConditionalRenderingEXT"/>
- <type name="VkConditionalRenderingBeginInfoEXT"/>
- <type name="VkPhysicalDeviceConditionalRenderingFeaturesEXT"/>
- <type name="VkCommandBufferInheritanceConditionalRenderingInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_float16_int8" number="83" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Alexander Galazin @alegal-arm" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_float16_int8"" name="VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"/>
- <type name="VkPhysicalDeviceShaderFloat16Int8FeaturesKHR"/>
- <type name="VkPhysicalDeviceFloat16Int8FeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_16bit_storage" number="84" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_storage_buffer_storage_class" author="KHR" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_16BIT_STORAGE_SPEC_VERSION"/>
- <enum value=""VK_KHR_16bit_storage"" name="VK_KHR_16BIT_STORAGE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"/>
- <type name="VkPhysicalDevice16BitStorageFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_incremental_present" number="85" type="device" author="KHR" requires="VK_KHR_swapchain" contact="Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="2" name="VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION"/>
- <enum value=""VK_KHR_incremental_present"" name="VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR"/>
- <type name="VkPresentRegionsKHR"/>
- <type name="VkPresentRegionKHR"/>
- <type name="VkRectLayerKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_descriptor_update_template" number="86" type="device" author="KHR" contact="Markus Tavenrath @mtavenrath" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION"/>
- <enum value=""VK_KHR_descriptor_update_template"" name="VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO"/>
- <enum extends="VkObjectType" name="VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR" alias="VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE"/>
- <command name="vkCreateDescriptorUpdateTemplateKHR"/>
- <command name="vkDestroyDescriptorUpdateTemplateKHR"/>
- <command name="vkUpdateDescriptorSetWithTemplateKHR"/>
- <type name="VkDescriptorUpdateTemplateKHR"/>
- <type name="VkDescriptorUpdateTemplateCreateFlagsKHR"/>
- <type name="VkDescriptorUpdateTemplateTypeKHR"/>
- <type name="VkDescriptorUpdateTemplateEntryKHR"/>
- <type name="VkDescriptorUpdateTemplateCreateInfoKHR"/>
- <enum extends="VkDescriptorUpdateTemplateType" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR" alias="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET"/>
- </require>
- <require extension="VK_KHR_push_descriptor">
- <command name="vkCmdPushDescriptorSetWithTemplateKHR"/>
- <enum value="1" extends="VkDescriptorUpdateTemplateType" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR" comment="Create descriptor update template for pushed descriptor updates"/>
- </require>
- <require extension="VK_EXT_debug_report">
- <enum extends="VkDebugReportObjectTypeEXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT" alias="VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT"/>
- </require>
- </extension>
- <extension name="VK_NVX_device_generated_commands" number="87" type="device" author="NVX" contact="Christoph Kubisch @pixeljetstream" supported="disabled">
- <require>
- <enum value="3" name="VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION"/>
- <enum value=""VK_NVX_device_generated_commands"" name="VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_clip_space_w_scaling" number="88" type="device" author="NV" contact="Eric Werness @ewerness-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION"/>
- <enum value=""VK_NV_clip_space_w_scaling"" name="VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"/>
- <type name="VkViewportWScalingNV"/>
- <type name="VkPipelineViewportWScalingStateCreateInfoNV"/>
- <command name="vkCmdSetViewportWScalingNV"/>
- </require>
- </extension>
- <extension name="VK_EXT_direct_mode_display" number="89" type="instance" requires="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION"/>
- <enum value=""VK_EXT_direct_mode_display"" name="VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME"/>
- <command name="vkReleaseDisplayEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_acquire_xlib_display" number="90" type="instance" requires="VK_EXT_direct_mode_display" author="NV" contact="James Jones @cubanismo" platform="xlib_xrandr" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION"/>
- <enum value=""VK_EXT_acquire_xlib_display"" name="VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME"/>
- <command name="vkAcquireXlibDisplayEXT"/>
- <command name="vkGetRandROutputDisplayEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_display_surface_counter" number="91" type="instance" requires="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION"/>
- <enum value=""VK_EXT_display_surface_counter"" name="VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT"/>
- <enum alias="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT" comment="Backwards-compatible alias containing a typo"/>
- <type name="VkSurfaceCounterFlagsEXT"/>
- <type name="VkSurfaceCounterFlagBitsEXT"/>
- <type name="VkSurfaceCapabilities2EXT"/>
- <command name="vkGetPhysicalDeviceSurfaceCapabilities2EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_display_control" number="92" type="device" requires="VK_EXT_display_surface_counter,VK_KHR_swapchain" author="NV" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_DISPLAY_CONTROL_SPEC_VERSION"/>
- <enum value=""VK_EXT_display_control"" name="VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT"/>
- <type name="VkDisplayPowerStateEXT"/>
- <type name="VkDeviceEventTypeEXT"/>
- <type name="VkDisplayEventTypeEXT"/>
- <type name="VkDisplayPowerInfoEXT"/>
- <type name="VkDeviceEventInfoEXT"/>
- <type name="VkDisplayEventInfoEXT"/>
- <type name="VkSwapchainCounterCreateInfoEXT"/>
- <command name="vkDisplayPowerControlEXT"/>
- <command name="vkRegisterDeviceEventEXT"/>
- <command name="vkRegisterDisplayEventEXT"/>
- <command name="vkGetSwapchainCounterEXT"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_display_timing" number="93" type="device" author="GOOGLE" requires="VK_KHR_swapchain" contact="Ian Elliott @ianelliottus" supported="vulkan">
- <require>
- <enum value="1" name="VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_display_timing"" name="VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE"/>
- <type name="VkRefreshCycleDurationGOOGLE"/>
- <type name="VkPastPresentationTimingGOOGLE"/>
- <type name="VkPresentTimesInfoGOOGLE"/>
- <type name="VkPresentTimeGOOGLE"/>
- <command name="vkGetRefreshCycleDurationGOOGLE"/>
- <command name="vkGetPastPresentationTimingGOOGLE"/>
- </require>
- </extension>
- <extension name="VK_RESERVED_do_not_use_94" number="94" supported="disabled" comment="Used for functionality subsumed into Vulkan 1.1 and not published as an extension">
- <require>
- <enum value="1" name="VK_RESERVED_DO_NOT_USE_94_SPEC_VERSION"/>
- <enum value=""VK_RESERVED_do_not_use_94"" name="VK_RESERVED_DO_NOT_USE_94_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_sample_mask_override_coverage" number="95" type="device" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION"/>
- <enum value=""VK_NV_sample_mask_override_coverage"" name="VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME"/>
- <comment>
- enum offset=0 was mistakenly used for the 1.1 core enum
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES
- (value=1000094000). Fortunately, no conflict resulted.
- </comment>
- </require>
- </extension>
- <extension name="VK_NV_geometry_shader_passthrough" number="96" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION"/>
- <enum value=""VK_NV_geometry_shader_passthrough"" name="VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_viewport_array2" number="97" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION"/>
- <enum value=""VK_NV_viewport_array2"" name="VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME"/>
- <enum alias="VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION" name="VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION" comment="Backwards-compatible alias containing a typo"/>
- <enum alias="VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME" name="VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME" comment="Backwards-compatible alias containing a typo"/>
- </require>
- </extension>
- <extension name="VK_NVX_multiview_per_view_attributes" number="98" type="device" requires="VK_KHR_multiview" author="NVX" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION"/>
- <enum value=""VK_NVX_multiview_per_view_attributes"" name="VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"/>
- <enum bitpos="0" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"/>
- <enum bitpos="1" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"/>
- <type name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"/>
- </require>
- </extension>
- <extension name="VK_NV_viewport_swizzle" number="99" type="device" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION"/>
- <enum value=""VK_NV_viewport_swizzle"" name="VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"/>
- <type name="VkViewportSwizzleNV"/>
- <type name="VkViewportCoordinateSwizzleNV"/>
- <type name="VkPipelineViewportSwizzleStateCreateInfoNV"/>
- <type name="VkPipelineViewportSwizzleStateCreateFlagsNV"/>
- </require>
- </extension>
- <extension name="VK_EXT_discard_rectangles" number="100" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION"/>
- <enum value=""VK_EXT_discard_rectangles"" name="VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT"/>
- <type name="VkPhysicalDeviceDiscardRectanglePropertiesEXT"/>
- <type name="VkPipelineDiscardRectangleStateCreateInfoEXT"/>
- <type name="VkPipelineDiscardRectangleStateCreateFlagsEXT"/>
- <type name="VkDiscardRectangleModeEXT"/>
- <command name="vkCmdSetDiscardRectangleEXT"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_101" number="101" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_101_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_101"" name="VK_NV_EXTENSION_101_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_conservative_rasterization" number="102" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION"/>
- <enum value=""VK_EXT_conservative_rasterization"" name="VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"/>
- <type name="VkPhysicalDeviceConservativeRasterizationPropertiesEXT"/>
- <type name="VkPipelineRasterizationConservativeStateCreateInfoEXT"/>
- <type name="VkPipelineRasterizationConservativeStateCreateFlagsEXT"/>
- <type name="VkConservativeRasterizationModeEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_depth_clip_enable" number="103" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" specialuse="d3demulation" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION"/>
- <enum value=""VK_EXT_depth_clip_enable"" name="VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"/>
- <type name="VkPhysicalDeviceDepthClipEnableFeaturesEXT"/>
- <type name="VkPipelineRasterizationDepthClipStateCreateInfoEXT"/>
- <type name="VkPipelineRasterizationDepthClipStateCreateFlagsEXT"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_104" number="104" author="NV" contact="Mathias Schott gitlab:@mschott" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_104_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_104"" name="VK_NV_EXTENSION_104_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_swapchain_colorspace" number="105" type="instance" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" requires="VK_KHR_surface" supported="vulkan">
- <require>
- <enum value="4" name="VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION"/>
- <enum value=""VK_EXT_swapchain_colorspace"" name="VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME"/>
- <enum offset="1" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"/>
- <enum offset="2" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT"/>
- <enum offset="3" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"/>
- <enum offset="4" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT"/>
- <enum offset="5" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT709_LINEAR_EXT"/>
- <enum offset="6" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT709_NONLINEAR_EXT"/>
- <enum offset="7" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT2020_LINEAR_EXT"/>
- <enum offset="8" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_HDR10_ST2084_EXT"/>
- <enum offset="9" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DOLBYVISION_EXT"/>
- <enum offset="10" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_HDR10_HLG_EXT"/>
- <enum offset="11" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT"/>
- <enum offset="12" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"/>
- <enum offset="13" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_PASS_THROUGH_EXT"/>
- <enum offset="14" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT"/>
- <enum extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DCI_P3_LINEAR_EXT" alias="VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT" comment="Deprecated name for backwards compatibility"/>
- </require>
- </extension>
- <extension name="VK_EXT_hdr_metadata" number="106" type="device" requires="VK_KHR_swapchain" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_HDR_METADATA_SPEC_VERSION"/>
- <enum value=""VK_EXT_hdr_metadata"" name="VK_EXT_HDR_METADATA_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_HDR_METADATA_EXT"/>
- <type name="VkHdrMetadataEXT"/>
- <type name="VkXYColorEXT"/>
- <command name="vkSetHdrMetadataEXT"/>
- </require>
- </extension>
- <extension name="VK_IMG_extension_107" number="107" author="IMG" contact="Michael Worcester @michaelworcester" supported="disabled">
- <require>
- <enum value="0" name="VK_IMG_EXTENSION_107_SPEC_VERSION"/>
- <enum value=""VK_IMG_extension_107"" name="VK_IMG_EXTENSION_107_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_IMG_extension_108" number="108" author="IMG" contact="Michael Worcester @michaelworcester" supported="disabled">
- <require>
- <enum value="0" name="VK_IMG_EXTENSION_108_SPEC_VERSION"/>
- <enum value=""VK_IMG_extension_108"" name="VK_IMG_EXTENSION_108_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_imageless_framebuffer" requires="VK_KHR_maintenance2,VK_KHR_image_format_list" number="109" author="KHR" contact="Tobias Hector @tobias" type="device" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION"/>
- <enum value=""VK_KHR_imageless_framebuffer"" name="VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME"/>
- <type name="VkPhysicalDeviceImagelessFramebufferFeaturesKHR"/>
- <type name="VkFramebufferAttachmentsCreateInfoKHR"/>
- <type name="VkFramebufferAttachmentImageInfoKHR"/>
- <type name="VkRenderPassAttachmentBeginInfoKHR"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR" alias="VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR" alias="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"/>
- <enum extends="VkFramebufferCreateFlagBits" name="VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR" alias="VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"/>
- </require>
- </extension>
- <extension name="VK_KHR_create_renderpass2" requires="VK_KHR_multiview,VK_KHR_maintenance2" number="110" contact="Tobias Hector @tobias" type="device" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_create_renderpass2"" name="VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR" alias="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR" alias="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR" alias="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR" alias="VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR" alias="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR" alias="VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR" alias="VK_STRUCTURE_TYPE_SUBPASS_END_INFO"/>
- <command name="vkCreateRenderPass2KHR"/>
- <command name="vkCmdBeginRenderPass2KHR"/>
- <command name="vkCmdNextSubpass2KHR"/>
- <command name="vkCmdEndRenderPass2KHR"/>
- <type name="VkRenderPassCreateInfo2KHR"/>
- <type name="VkAttachmentDescription2KHR"/>
- <type name="VkAttachmentReference2KHR"/>
- <type name="VkSubpassDescription2KHR"/>
- <type name="VkSubpassDependency2KHR"/>
- <type name="VkSubpassBeginInfoKHR"/>
- <type name="VkSubpassEndInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_IMG_extension_111" number="111" author="IMG" contact="Michael Worcester @michaelworcester" supported="disabled">
- <require>
- <enum value="0" name="VK_IMG_EXTENSION_111_SPEC_VERSION"/>
- <enum value=""VK_IMG_extension_111"" name="VK_IMG_EXTENSION_111_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_shared_presentable_image" number="112" type="device" requires="VK_KHR_swapchain,VK_KHR_get_physical_device_properties2,VK_KHR_get_surface_capabilities2" author="KHR" contact="Alon Or-bach @alonorbach" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION"/>
- <enum value=""VK_KHR_shared_presentable_image"" name="VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"/>
- <enum offset="0" extends="VkPresentModeKHR" name="VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR"/>
- <enum offset="1" extends="VkPresentModeKHR" name="VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR"/>
- <enum offset="0" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR"/>
- <type name="VkSharedPresentSurfaceCapabilitiesKHR"/>
- <command name="vkGetSwapchainStatusKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_fence_capabilities" number="113" type="instance" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jesse Hall @critsec" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_fence_capabilities"" name="VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"/>
- <enum name="VK_LUID_SIZE_KHR"/>
- <type name="VkExternalFenceHandleTypeFlagsKHR"/>
- <type name="VkExternalFenceHandleTypeFlagBitsKHR"/>
- <enum extends="VkExternalFenceHandleTypeFlagBits" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR" alias="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"/>
- <enum extends="VkExternalFenceHandleTypeFlagBits" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR" alias="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"/>
- <enum extends="VkExternalFenceHandleTypeFlagBits" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR" alias="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"/>
- <enum extends="VkExternalFenceHandleTypeFlagBits" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR" alias="VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"/>
- <type name="VkExternalFenceFeatureFlagsKHR"/>
- <type name="VkExternalFenceFeatureFlagBitsKHR"/>
- <enum extends="VkExternalFenceFeatureFlagBits" name="VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR" alias="VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"/>
- <enum extends="VkExternalFenceFeatureFlagBits" name="VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR" alias="VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"/>
- <type name="VkPhysicalDeviceExternalFenceInfoKHR"/>
- <type name="VkExternalFencePropertiesKHR"/>
- <type name="VkPhysicalDeviceIDPropertiesKHR"/>
- <command name="vkGetPhysicalDeviceExternalFencePropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_fence" number="114" type="device" requires="VK_KHR_external_fence_capabilities" author="KHR" contact="Jesse Hall @critsec" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_FENCE_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_fence"" name="VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"/>
- <type name="VkFenceImportFlagsKHR"/>
- <type name="VkFenceImportFlagBitsKHR"/>
- <enum extends="VkFenceImportFlagBits" name="VK_FENCE_IMPORT_TEMPORARY_BIT_KHR" alias="VK_FENCE_IMPORT_TEMPORARY_BIT"/>
- <type name="VkExportFenceCreateInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_fence_win32" number="115" type="device" requires="VK_KHR_external_fence" author="KHR" contact="Jesse Hall @critsec" platform="win32" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_fence_win32"" name="VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"/>
- <type name="VkImportFenceWin32HandleInfoKHR"/>
- <type name="VkExportFenceWin32HandleInfoKHR"/>
- <type name="VkFenceGetWin32HandleInfoKHR"/>
- <command name="vkImportFenceWin32HandleKHR"/>
- <command name="vkGetFenceWin32HandleKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_external_fence_fd" number="116" type="device" requires="VK_KHR_external_fence" author="KHR" contact="Jesse Hall @critsec" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION"/>
- <enum value=""VK_KHR_external_fence_fd"" name="VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"/>
- <type name="VkImportFenceFdInfoKHR"/>
- <type name="VkFenceGetFdInfoKHR"/>
- <command name="vkImportFenceFdKHR"/>
- <command name="vkGetFenceFdKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_performance_query" number="117" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Alon Or-bach @alonorbach" specialuse="devtools" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION"/>
- <enum value=""VK_KHR_performance_query"" name="VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkQueryType" name="VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"/>
- <type name="VkPhysicalDevicePerformanceQueryFeaturesKHR"/>
- <type name="VkPhysicalDevicePerformanceQueryPropertiesKHR"/>
- <type name="VkPerformanceCounterKHR"/>
- <type name="VkPerformanceCounterDescriptionKHR"/>
- <type name="VkPerformanceCounterDescriptionFlagsKHR"/>
- <type name="VkPerformanceCounterDescriptionFlagBitsKHR"/>
- <type name="VkQueryPoolPerformanceCreateInfoKHR"/>
- <type name="VkPerformanceCounterScopeKHR"/>
- <type name="VkPerformanceCounterStorageKHR"/>
- <type name="VkPerformanceCounterUnitKHR"/>
- <type name="VkPerformanceCounterResultKHR"/>
- <type name="VkAcquireProfilingLockInfoKHR"/>
- <type name="VkAcquireProfilingLockFlagsKHR"/>
- <type name="VkAcquireProfilingLockFlagBitsKHR"/>
- <type name="VkPerformanceQuerySubmitInfoKHR"/>
- <command name="vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"/>
- <command name="vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"/>
- <command name="vkAcquireProfilingLockKHR"/>
- <command name="vkReleaseProfilingLockKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_maintenance2" number="118" type="device" author="KHR" contact="Michael Worcester @michaelworcester" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_MAINTENANCE_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_maintenance2"" name="VK_KHR_MAINTENANCE_2_EXTENSION_NAME"/>
- <enum alias="VK_KHR_MAINTENANCE_2_SPEC_VERSION" name="VK_KHR_MAINTENANCE2_SPEC_VERSION" comment="Backwards-compatible alias containing a typo"/>
- <enum alias="VK_KHR_MAINTENANCE_2_EXTENSION_NAME" name="VK_KHR_MAINTENANCE2_EXTENSION_NAME" comment="Backwards-compatible alias containing a typo"/>
- <enum extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR" alias="VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"/>
- <enum extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR" alias="VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"/>
- <enum extends="VkImageLayout" name="VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR" alias="VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"/>
- <enum extends="VkImageLayout" name="VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR" alias="VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"/>
- <type name="VkPhysicalDevicePointClippingPropertiesKHR"/>
- <type name="VkPointClippingBehaviorKHR"/>
- <enum extends="VkPointClippingBehavior" name="VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR" alias="VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"/>
- <enum extends="VkPointClippingBehavior" name="VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR" alias="VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"/>
- <type name="VkRenderPassInputAttachmentAspectCreateInfoKHR"/>
- <type name="VkInputAttachmentAspectReferenceKHR"/>
- <type name="VkImageViewUsageCreateInfoKHR"/>
- <type name="VkTessellationDomainOriginKHR"/>
- <enum extends="VkTessellationDomainOrigin" name="VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR" alias="VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT"/>
- <enum extends="VkTessellationDomainOrigin" name="VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR" alias="VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT"/>
- <type name="VkPipelineTessellationDomainOriginStateCreateInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_119" number="119" author="KHR" contact="Michael Worcester @michaelworcester" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_119_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_119"" name="VK_KHR_EXTENSION_119_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_get_surface_capabilities2" number="120" type="instance" requires="VK_KHR_surface" author="KHR" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_get_surface_capabilities2"" name="VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR"/>
- <type name="VkPhysicalDeviceSurfaceInfo2KHR"/>
- <type name="VkSurfaceCapabilities2KHR"/>
- <type name="VkSurfaceFormat2KHR"/>
- <command name="vkGetPhysicalDeviceSurfaceCapabilities2KHR"/>
- <command name="vkGetPhysicalDeviceSurfaceFormats2KHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_variable_pointers" number="121" type="device" author="KHR" contact="Jesse Hall @critsec" requires="VK_KHR_get_physical_device_properties2,VK_KHR_storage_buffer_storage_class" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_VARIABLE_POINTERS_SPEC_VERSION"/>
- <enum value=""VK_KHR_variable_pointers"" name="VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR"/>
- <type name="VkPhysicalDeviceVariablePointerFeaturesKHR"/>
- <type name="VkPhysicalDeviceVariablePointersFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_get_display_properties2" number="122" type="instance" requires="VK_KHR_display" author="KHR" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_get_display_properties2"" name="VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR"/>
- <type name="VkDisplayProperties2KHR"/>
- <type name="VkDisplayPlaneProperties2KHR"/>
- <type name="VkDisplayModeProperties2KHR"/>
- <type name="VkDisplayPlaneInfo2KHR"/>
- <type name="VkDisplayPlaneCapabilities2KHR"/>
- <command name="vkGetPhysicalDeviceDisplayProperties2KHR"/>
- <command name="vkGetPhysicalDeviceDisplayPlaneProperties2KHR"/>
- <command name="vkGetDisplayModeProperties2KHR"/>
- <command name="vkGetDisplayPlaneCapabilities2KHR"/>
- </require>
- </extension>
- <extension name="VK_MVK_ios_surface" number="123" type="instance" requires="VK_KHR_surface" platform="ios" supported="vulkan" author="MVK" contact="Bill Hollings @billhollings" deprecatedby="VK_EXT_metal_surface">
- <require>
- <enum value="3" name="VK_MVK_IOS_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_MVK_ios_surface"" name="VK_MVK_IOS_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"/>
- <type name="VkIOSSurfaceCreateFlagsMVK"/>
- <type name="VkIOSSurfaceCreateInfoMVK"/>
- <command name="vkCreateIOSSurfaceMVK"/>
- </require>
- </extension>
- <extension name="VK_MVK_macos_surface" number="124" type="instance" requires="VK_KHR_surface" platform="macos" supported="vulkan" author="MVK" contact="Bill Hollings @billhollings" deprecatedby="VK_EXT_metal_surface">
- <require>
- <enum value="3" name="VK_MVK_MACOS_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_MVK_macos_surface"" name="VK_MVK_MACOS_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"/>
- <type name="VkMacOSSurfaceCreateFlagsMVK"/>
- <type name="VkMacOSSurfaceCreateInfoMVK"/>
- <command name="vkCreateMacOSSurfaceMVK"/>
- </require>
- </extension>
- <extension name="VK_MVK_moltenvk" number="125" type="instance" author="MVK" contact="Bill Hollings @billhollings" supported="vulkan">
- <require>
- <enum value="0" name="VK_MVK_MOLTENVK_SPEC_VERSION"/>
- <enum value=""VK_MVK_moltenvk"" name="VK_MVK_MOLTENVK_EXTENSION_NAME"/>
- <command name="vkGetMTLDeviceMVK"/>
- <command name="vkSetMTLTextureMVK"/>
- <command name="vkGetMTLTextureMVK"/>
- <command name="vkGetMTLBufferMVK"/>
- <command name="vkUseIOSurfaceMVK"/>
- <command name="vkGetIOSurfaceMVK"/>
- </require>
- </extension>
- <extension name="VK_EXT_external_memory_dma_buf" number="126" type="device" requires="VK_KHR_external_memory_fd" author="EXT" contact="Chad Versace @chadversary" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION"/>
- <enum value=""VK_EXT_external_memory_dma_buf"" name="VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME"/>
- <enum bitpos="9" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_queue_family_foreign" number="127" type="device" author="EXT" requires="VK_KHR_external_memory" contact="Chad Versace @chadversary" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION"/>
- <enum value=""VK_EXT_queue_family_foreign"" name="VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME"/>
- <enum name="VK_QUEUE_FAMILY_FOREIGN_EXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_dedicated_allocation" number="128" type="device" author="KHR" requires="VK_KHR_get_memory_requirements2" contact="James Jones @cubanismo" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="3" name="VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION"/>
- <enum value=""VK_KHR_dedicated_allocation"" name="VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR" alias="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"/>
- <type name="VkMemoryDedicatedRequirementsKHR"/>
- <type name="VkMemoryDedicatedAllocateInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_debug_utils" number="129" type="instance" author="EXT" contact="Mark Young @marky-lunarg" specialuse="debugging" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_DEBUG_UTILS_SPEC_VERSION"/>
- <enum value=""VK_EXT_debug_utils"" name="VK_EXT_DEBUG_UTILS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"/>
- <type name="PFN_vkDebugUtilsMessengerCallbackEXT"/>
- <type name="VkDebugUtilsLabelEXT"/>
- <type name="VkDebugUtilsMessageSeverityFlagBitsEXT"/>
- <type name="VkDebugUtilsMessageSeverityFlagsEXT"/>
- <type name="VkDebugUtilsMessageTypeFlagBitsEXT"/>
- <type name="VkDebugUtilsMessageTypeFlagsEXT"/>
- <type name="VkDebugUtilsMessengerCallbackDataEXT"/>
- <type name="VkDebugUtilsMessengerCallbackDataFlagsEXT"/>
- <type name="VkDebugUtilsMessengerCreateFlagsEXT"/>
- <type name="VkDebugUtilsMessengerCreateInfoEXT"/>
- <type name="VkDebugUtilsMessengerEXT"/>
- <type name="VkDebugUtilsObjectNameInfoEXT"/>
- <type name="VkDebugUtilsObjectTagInfoEXT"/>
- <command name="vkSetDebugUtilsObjectNameEXT"/>
- <command name="vkSetDebugUtilsObjectTagEXT"/>
- <command name="vkQueueBeginDebugUtilsLabelEXT"/>
- <command name="vkQueueEndDebugUtilsLabelEXT"/>
- <command name="vkQueueInsertDebugUtilsLabelEXT"/>
- <command name="vkCmdBeginDebugUtilsLabelEXT"/>
- <command name="vkCmdEndDebugUtilsLabelEXT"/>
- <command name="vkCmdInsertDebugUtilsLabelEXT"/>
- <command name="vkCreateDebugUtilsMessengerEXT"/>
- <command name="vkDestroyDebugUtilsMessengerEXT"/>
- <command name="vkSubmitDebugUtilsMessageEXT"/>
- </require>
- </extension>
- <extension name="VK_ANDROID_external_memory_android_hardware_buffer" number="130" type="device" author="ANDROID" requires="VK_KHR_sampler_ycbcr_conversion,VK_KHR_external_memory,VK_EXT_queue_family_foreign,VK_KHR_dedicated_allocation" platform="android" contact="Jesse Hall @critsec" supported="vulkan">
- <require>
- <enum value="4" name="VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION"/>
- <enum value=""VK_ANDROID_external_memory_android_hardware_buffer"" name="VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME"/>
- <enum bitpos="10" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"/>
- <type name="VkAndroidHardwareBufferUsageANDROID"/>
- <type name="VkAndroidHardwareBufferPropertiesANDROID"/>
- <type name="VkAndroidHardwareBufferFormatPropertiesANDROID"/>
- <type name="VkImportAndroidHardwareBufferInfoANDROID"/>
- <type name="VkMemoryGetAndroidHardwareBufferInfoANDROID"/>
- <type name="VkExternalFormatANDROID"/>
- <command name="vkGetAndroidHardwareBufferPropertiesANDROID"/>
- <command name="vkGetMemoryAndroidHardwareBufferANDROID"/>
- <type name="AHardwareBuffer"/>
- </require>
- <require extension="VK_KHR_format_feature_flags2">
- <type name="VkAndroidHardwareBufferFormatProperties2ANDROID"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"/>
- </require>
- </extension>
- <extension name="VK_EXT_sampler_filter_minmax" number="131" type="device" author="NV" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="2" name="VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION"/>
- <enum value=""VK_EXT_sampler_filter_minmax"" name="VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT" alias="VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT" alias="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"/>
- <enum extends="VkSamplerReductionMode" name="VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT" alias="VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE"/>
- <enum extends="VkSamplerReductionMode" name="VK_SAMPLER_REDUCTION_MODE_MIN_EXT" alias="VK_SAMPLER_REDUCTION_MODE_MIN"/>
- <enum extends="VkSamplerReductionMode" name="VK_SAMPLER_REDUCTION_MODE_MAX_EXT" alias="VK_SAMPLER_REDUCTION_MODE_MAX"/>
- <type name="VkSamplerReductionModeEXT"/>
- <type name="VkSamplerReductionModeCreateInfoEXT"/>
- <type name="VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_storage_buffer_storage_class" number="132" type="device" author="KHR" contact="Alexander Galazin @alegal-arm" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION"/>
- <enum value=""VK_KHR_storage_buffer_storage_class"" name="VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_gpu_shader_int16" number="133" type="device" author="AMD" contact="Qun Lin @linqun" supported="vulkan" deprecatedby="VK_KHR_shader_float16_int8">
- <require>
- <enum value="2" name="VK_AMD_GPU_SHADER_INT16_SPEC_VERSION"/>
- <enum value=""VK_AMD_gpu_shader_int16"" name="VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_134" number="134" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_134_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_134"" name="VK_AMD_EXTENSION_134_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_135" number="135" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_135_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_135"" name="VK_AMD_EXTENSION_135_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_136" number="136" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_136_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_136"" name="VK_AMD_EXTENSION_136_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_mixed_attachment_samples" number="137" type="device" author="AMD" contact="Matthaeus G. Chajdas @anteru" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION"/>
- <enum value=""VK_AMD_mixed_attachment_samples"" name="VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_fragment_mask" number="138" author="AMD" contact="Aaron Hagan @AaronHaganAMD" supported="vulkan" type="device">
- <require>
- <enum value="1" name="VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_fragment_mask"" name="VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_inline_uniform_block" number="139" type="device" author="EXT" requires="VK_KHR_get_physical_device_properties2,VK_KHR_maintenance1" contact="Daniel Rakos @aqnuep" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION"/>
- <enum value=""VK_EXT_inline_uniform_block"" name="VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME"/>
- <enum offset="0" extends="VkDescriptorType" name="VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT"/>
- <type name="VkPhysicalDeviceInlineUniformBlockFeaturesEXT"/>
- <type name="VkPhysicalDeviceInlineUniformBlockPropertiesEXT"/>
- <type name="VkWriteDescriptorSetInlineUniformBlockEXT"/>
- <type name="VkDescriptorPoolInlineUniformBlockCreateInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_140" number="140" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_140_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_140"" name="VK_AMD_EXTENSION_140_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_stencil_export" number="141" type="device" author="EXT" contact="Dominik Witczak @dominikwitczakamd" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_stencil_export"" name="VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_142" number="142" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_142_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_142"" name="VK_AMD_EXTENSION_142_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_143" number="143" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_143_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_143"" name="VK_AMD_EXTENSION_143_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_sample_locations" number="144" type="device" author="AMD" contact="Daniel Rakos @drakos-amd" supported="vulkan" requires="VK_KHR_get_physical_device_properties2">
- <require>
- <enum value="1" name="VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION"/>
- <enum value=""VK_EXT_sample_locations"" name="VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME"/>
- <enum bitpos="12" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT"/>
- <type name="VkSampleLocationEXT"/>
- <type name="VkSampleLocationsInfoEXT"/>
- <type name="VkAttachmentSampleLocationsEXT"/>
- <type name="VkSubpassSampleLocationsEXT"/>
- <type name="VkRenderPassSampleLocationsBeginInfoEXT"/>
- <type name="VkPipelineSampleLocationsStateCreateInfoEXT"/>
- <type name="VkPhysicalDeviceSampleLocationsPropertiesEXT"/>
- <type name="VkMultisamplePropertiesEXT"/>
- <command name="vkCmdSetSampleLocationsEXT"/>
- <command name="vkGetPhysicalDeviceMultisamplePropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_relaxed_block_layout" number="145" type="device" author="KHR" contact="John Kessenich @johnkslang" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION"/>
- <enum value=""VK_KHR_relaxed_block_layout"" name="VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_RESERVED_do_not_use_146" number="146" supported="disabled" comment="Used for functionality subsumed into Vulkan 1.1 and not published as an extension">
- <require>
- <enum value="1" name="VK_RESERVED_DO_NOT_USE_146_SPEC_VERSION"/>
- <enum value=""VK_RESERVED_do_not_use_146"" name="VK_RESERVED_DO_NOT_USE_146_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_get_memory_requirements2" number="147" type="device" author="KHR" contact="Jason Ekstrand @jekstrand" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_get_memory_requirements2"" name="VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR" alias="VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR" alias="VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR" alias="VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR" alias="VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR" alias="VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"/>
- <type name="VkBufferMemoryRequirementsInfo2KHR"/>
- <type name="VkImageMemoryRequirementsInfo2KHR"/>
- <type name="VkImageSparseMemoryRequirementsInfo2KHR"/>
- <type name="VkMemoryRequirements2KHR"/>
- <type name="VkSparseImageMemoryRequirements2KHR"/>
- <command name="vkGetImageMemoryRequirements2KHR"/>
- <command name="vkGetBufferMemoryRequirements2KHR"/>
- <command name="vkGetImageSparseMemoryRequirements2KHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_image_format_list" number="148" type="device" author="KHR" contact="Jason Ekstrand @jekstrand" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION"/>
- <enum value=""VK_KHR_image_format_list"" name="VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"/>
- <type name="VkImageFormatListCreateInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_blend_operation_advanced" number="149" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION"/>
- <enum value=""VK_EXT_blend_operation_advanced"" name="VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"/>
- <type name="VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"/>
- <type name="VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT"/>
- <type name="VkPipelineColorBlendAdvancedStateCreateInfoEXT"/>
- <type name="VkBlendOverlapEXT"/>
- <enum offset="0" extends="VkBlendOp" name="VK_BLEND_OP_ZERO_EXT"/>
- <enum offset="1" extends="VkBlendOp" name="VK_BLEND_OP_SRC_EXT"/>
- <enum offset="2" extends="VkBlendOp" name="VK_BLEND_OP_DST_EXT"/>
- <enum offset="3" extends="VkBlendOp" name="VK_BLEND_OP_SRC_OVER_EXT"/>
- <enum offset="4" extends="VkBlendOp" name="VK_BLEND_OP_DST_OVER_EXT"/>
- <enum offset="5" extends="VkBlendOp" name="VK_BLEND_OP_SRC_IN_EXT"/>
- <enum offset="6" extends="VkBlendOp" name="VK_BLEND_OP_DST_IN_EXT"/>
- <enum offset="7" extends="VkBlendOp" name="VK_BLEND_OP_SRC_OUT_EXT"/>
- <enum offset="8" extends="VkBlendOp" name="VK_BLEND_OP_DST_OUT_EXT"/>
- <enum offset="9" extends="VkBlendOp" name="VK_BLEND_OP_SRC_ATOP_EXT"/>
- <enum offset="10" extends="VkBlendOp" name="VK_BLEND_OP_DST_ATOP_EXT"/>
- <enum offset="11" extends="VkBlendOp" name="VK_BLEND_OP_XOR_EXT"/>
- <enum offset="12" extends="VkBlendOp" name="VK_BLEND_OP_MULTIPLY_EXT"/>
- <enum offset="13" extends="VkBlendOp" name="VK_BLEND_OP_SCREEN_EXT"/>
- <enum offset="14" extends="VkBlendOp" name="VK_BLEND_OP_OVERLAY_EXT"/>
- <enum offset="15" extends="VkBlendOp" name="VK_BLEND_OP_DARKEN_EXT"/>
- <enum offset="16" extends="VkBlendOp" name="VK_BLEND_OP_LIGHTEN_EXT"/>
- <enum offset="17" extends="VkBlendOp" name="VK_BLEND_OP_COLORDODGE_EXT"/>
- <enum offset="18" extends="VkBlendOp" name="VK_BLEND_OP_COLORBURN_EXT"/>
- <enum offset="19" extends="VkBlendOp" name="VK_BLEND_OP_HARDLIGHT_EXT"/>
- <enum offset="20" extends="VkBlendOp" name="VK_BLEND_OP_SOFTLIGHT_EXT"/>
- <enum offset="21" extends="VkBlendOp" name="VK_BLEND_OP_DIFFERENCE_EXT"/>
- <enum offset="22" extends="VkBlendOp" name="VK_BLEND_OP_EXCLUSION_EXT"/>
- <enum offset="23" extends="VkBlendOp" name="VK_BLEND_OP_INVERT_EXT"/>
- <enum offset="24" extends="VkBlendOp" name="VK_BLEND_OP_INVERT_RGB_EXT"/>
- <enum offset="25" extends="VkBlendOp" name="VK_BLEND_OP_LINEARDODGE_EXT"/>
- <enum offset="26" extends="VkBlendOp" name="VK_BLEND_OP_LINEARBURN_EXT"/>
- <enum offset="27" extends="VkBlendOp" name="VK_BLEND_OP_VIVIDLIGHT_EXT"/>
- <enum offset="28" extends="VkBlendOp" name="VK_BLEND_OP_LINEARLIGHT_EXT"/>
- <enum offset="29" extends="VkBlendOp" name="VK_BLEND_OP_PINLIGHT_EXT"/>
- <enum offset="30" extends="VkBlendOp" name="VK_BLEND_OP_HARDMIX_EXT"/>
- <enum offset="31" extends="VkBlendOp" name="VK_BLEND_OP_HSL_HUE_EXT"/>
- <enum offset="32" extends="VkBlendOp" name="VK_BLEND_OP_HSL_SATURATION_EXT"/>
- <enum offset="33" extends="VkBlendOp" name="VK_BLEND_OP_HSL_COLOR_EXT"/>
- <enum offset="34" extends="VkBlendOp" name="VK_BLEND_OP_HSL_LUMINOSITY_EXT"/>
- <enum offset="35" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_EXT"/>
- <enum offset="36" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_CLAMPED_EXT"/>
- <enum offset="37" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT"/>
- <enum offset="38" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_DARKER_EXT"/>
- <enum offset="39" extends="VkBlendOp" name="VK_BLEND_OP_MINUS_EXT"/>
- <enum offset="40" extends="VkBlendOp" name="VK_BLEND_OP_MINUS_CLAMPED_EXT"/>
- <enum offset="41" extends="VkBlendOp" name="VK_BLEND_OP_CONTRAST_EXT"/>
- <enum offset="42" extends="VkBlendOp" name="VK_BLEND_OP_INVERT_OVG_EXT"/>
- <enum offset="43" extends="VkBlendOp" name="VK_BLEND_OP_RED_EXT"/>
- <enum offset="44" extends="VkBlendOp" name="VK_BLEND_OP_GREEN_EXT"/>
- <enum offset="45" extends="VkBlendOp" name="VK_BLEND_OP_BLUE_EXT"/>
- <enum bitpos="19" extends="VkAccessFlagBits" name="VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_NV_fragment_coverage_to_color" number="150" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION"/>
- <enum value=""VK_NV_fragment_coverage_to_color"" name="VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"/>
- <type name="VkPipelineCoverageToColorStateCreateFlagsNV"/>
- <type name="VkPipelineCoverageToColorStateCreateInfoNV"/>
- </require>
- </extension>
- <extension name="VK_KHR_acceleration_structure" number="151" type="device" requiresCore="1.1" requires="VK_EXT_descriptor_indexing,VK_KHR_buffer_device_address,VK_KHR_deferred_host_operations" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" sortorder="1">
- <require>
- <enum value="13" name="VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION"/>
- <enum value=""VK_KHR_acceleration_structure"" name="VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR"/>
- <enum offset="10" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR"/>
- <enum offset="11" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"/>
- <enum offset="12" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"/>
- <enum offset="13" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"/>
- <enum offset="14" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"/>
- <enum offset="17" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR"/>
- <enum offset="20" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"/>
- <enum bitpos="25" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"/>
- <enum offset="0" extends="VkDescriptorType" name="VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR"/>
- <enum bitpos="21" extends="VkAccessFlagBits" name="VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"/>
- <enum bitpos="22" extends="VkAccessFlagBits" name="VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"/>
- <enum offset="0" extends="VkQueryType" name="VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR"/>
- <enum offset="1" extends="VkQueryType" name="VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"/>
- <enum offset="0" extends="VkDebugReportObjectTypeEXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT"/>
- <enum offset="0" extends="VkIndexType" extnumber="166" name="VK_INDEX_TYPE_NONE_KHR"/>
- <enum bitpos="29" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"/>
- <enum bitpos="19" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"/>
- <enum bitpos="20" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"/>
- <type name="VkAccelerationStructureTypeKHR"/>
- <type name="VkDeviceOrHostAddressKHR"/>
- <type name="VkDeviceOrHostAddressConstKHR"/>
- <type name="VkAccelerationStructureBuildRangeInfoKHR"/>
- <type name="VkAabbPositionsKHR"/>
- <type name="VkAccelerationStructureGeometryTrianglesDataKHR"/>
- <type name="VkTransformMatrixKHR"/>
- <type name="VkAccelerationStructureBuildGeometryInfoKHR"/>
- <type name="VkAccelerationStructureBuildTypeKHR"/>
- <type name="VkAccelerationStructureGeometryAabbsDataKHR"/>
- <type name="VkAccelerationStructureInstanceKHR"/>
- <type name="VkAccelerationStructureGeometryInstancesDataKHR"/>
- <type name="VkAccelerationStructureGeometryDataKHR"/>
- <type name="VkAccelerationStructureGeometryKHR"/>
- <type name="VkGeometryFlagsKHR"/>
- <type name="VkGeometryInstanceFlagsKHR"/>
- <type name="VkGeometryFlagBitsKHR"/>
- <type name="VkGeometryInstanceFlagBitsKHR"/>
- <type name="VkAccelerationStructureCreateInfoKHR"/>
- <type name="VkAccelerationStructureKHR"/>
- <type name="VkBuildAccelerationStructureFlagBitsKHR"/>
- <type name="VkBuildAccelerationStructureFlagsKHR"/>
- <type name="VkCopyAccelerationStructureModeKHR"/>
- <type name="VkGeometryTypeKHR"/>
- <type name="VkWriteDescriptorSetAccelerationStructureKHR"/>
- <type name="VkPhysicalDeviceAccelerationStructureFeaturesKHR"/>
- <type name="VkPhysicalDeviceAccelerationStructurePropertiesKHR"/>
- <type name="VkAccelerationStructureDeviceAddressInfoKHR"/>
- <type name="VkAccelerationStructureVersionInfoKHR"/>
- <type name="VkCopyAccelerationStructureToMemoryInfoKHR"/>
- <type name="VkCopyMemoryToAccelerationStructureInfoKHR"/>
- <type name="VkCopyAccelerationStructureInfoKHR"/>
- <type name="VkAccelerationStructureCompatibilityKHR"/>
- <type name="VkAccelerationStructureCreateFlagBitsKHR"/>
- <type name="VkAccelerationStructureCreateFlagsKHR"/>
- <type name="VkBuildAccelerationStructureModeKHR"/>
- <type name="VkAccelerationStructureBuildSizesInfoKHR"/>
- <command name="vkCreateAccelerationStructureKHR"/>
- <command name="vkDestroyAccelerationStructureKHR"/>
- <command name="vkCmdBuildAccelerationStructuresKHR"/>
- <command name="vkCmdBuildAccelerationStructuresIndirectKHR"/>
- <command name="vkBuildAccelerationStructuresKHR"/>
- <command name="vkCopyAccelerationStructureKHR"/>
- <command name="vkCopyAccelerationStructureToMemoryKHR"/>
- <command name="vkCopyMemoryToAccelerationStructureKHR"/>
- <command name="vkWriteAccelerationStructuresPropertiesKHR"/>
- <command name="vkCmdCopyAccelerationStructureKHR"/>
- <command name="vkCmdCopyAccelerationStructureToMemoryKHR"/>
- <command name="vkCmdCopyMemoryToAccelerationStructureKHR"/>
- <command name="vkGetAccelerationStructureDeviceAddressKHR"/>
- <command name="vkCmdWriteAccelerationStructuresPropertiesKHR"/>
- <command name="vkGetDeviceAccelerationStructureCompatibilityKHR"/>
- <command name="vkGetAccelerationStructureBuildSizesKHR"/>
- </require>
- <require extension="VK_KHR_format_feature_flags2">
- <enum bitpos="29" extends="VkFormatFeatureFlagBits2KHR" name="VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_ray_tracing_pipeline" number="348" type="device" requiresCore="1.1" requires="VK_KHR_spirv_1_4,VK_KHR_acceleration_structure" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" sortorder="1">
- <require>
- <enum value="1" name="VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION"/>
- <enum value=""VK_KHR_ray_tracing_pipeline"" name="VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME"/>
- <enum name="VK_SHADER_UNUSED_KHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"/>
- <enum offset="15" extends="VkStructureType" extnumber="151" name="VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR"/>
- <enum offset="16" extends="VkStructureType" extnumber="151" name="VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"/>
- <enum offset="18" extends="VkStructureType" extnumber="151" name="VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"/>
- <enum bitpos="8" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_RAYGEN_BIT_KHR"/>
- <enum bitpos="9" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_ANY_HIT_BIT_KHR"/>
- <enum bitpos="10" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"/>
- <enum bitpos="11" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_MISS_BIT_KHR"/>
- <enum bitpos="12" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_INTERSECTION_BIT_KHR"/>
- <enum bitpos="13" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_CALLABLE_BIT_KHR"/>
- <enum bitpos="21" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"/>
- <enum bitpos="10" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"/>
- <enum offset="0" extends="VkPipelineBindPoint" extnumber="166" name="VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"/>
- <enum bitpos="14" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"/>
- <enum bitpos="15" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"/>
- <enum bitpos="16" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"/>
- <enum bitpos="17" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"/>
- <enum bitpos="12" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"/>
- <enum bitpos="13" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR"/>
- <enum bitpos="19" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR"/>
- <type name="VkRayTracingShaderGroupCreateInfoKHR"/>
- <type name="VkRayTracingShaderGroupTypeKHR"/>
- <type name="VkRayTracingPipelineCreateInfoKHR"/>
- <type name="VkPhysicalDeviceRayTracingPipelineFeaturesKHR"/>
- <type name="VkPhysicalDeviceRayTracingPipelinePropertiesKHR"/>
- <type name="VkStridedDeviceAddressRegionKHR"/>
- <type name="VkTraceRaysIndirectCommandKHR"/>
- <type name="VkRayTracingPipelineInterfaceCreateInfoKHR"/>
- <type name="VkShaderGroupShaderKHR"/>
- <command name="vkCmdTraceRaysKHR"/>
- <command name="vkCreateRayTracingPipelinesKHR"/>
- <command name="vkGetRayTracingShaderGroupHandlesKHR"/>
- <command name="vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"/>
- <command name="vkCmdTraceRaysIndirectKHR"/>
- <command name="vkGetRayTracingShaderGroupStackSizeKHR"/>
- <command name="vkCmdSetRayTracingPipelineStackSizeKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_ray_query" number="349" type="device" requiresCore="1.1" requires="VK_KHR_spirv_1_4,VK_KHR_acceleration_structure" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" sortorder="1">
- <require>
- <enum value="1" name="VK_KHR_RAY_QUERY_SPEC_VERSION"/>
- <enum value=""VK_KHR_ray_query"" name="VK_KHR_RAY_QUERY_EXTENSION_NAME"/>
- <enum offset="13" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"/>
- <type name="VkPhysicalDeviceRayQueryFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_152" number="152" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_152_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_152"" name="VK_NV_EXTENSION_152_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_framebuffer_mixed_samples" number="153" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION"/>
- <enum value=""VK_NV_framebuffer_mixed_samples"" name="VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"/>
- <type name="VkPipelineCoverageModulationStateCreateInfoNV"/>
- <type name="VkPipelineCoverageModulationStateCreateFlagsNV"/>
- <type name="VkCoverageModulationModeNV"/>
- </require>
- </extension>
- <extension name="VK_NV_fill_rectangle" number="154" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_FILL_RECTANGLE_SPEC_VERSION"/>
- <enum value=""VK_NV_fill_rectangle"" name="VK_NV_FILL_RECTANGLE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkPolygonMode" name="VK_POLYGON_MODE_FILL_RECTANGLE_NV"/>
- </require>
- </extension>
- <extension name="VK_NV_shader_sm_builtins" number="155" type="device" requiresCore="1.1" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION"/>
- <enum value=""VK_NV_shader_sm_builtins"" name="VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"/>
- <type name="VkPhysicalDeviceShaderSMBuiltinsPropertiesNV"/>
- <type name="VkPhysicalDeviceShaderSMBuiltinsFeaturesNV"/>
- </require>
- </extension>
- <extension name="VK_EXT_post_depth_coverage" number="156" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION"/>
- <enum value=""VK_EXT_post_depth_coverage"" name="VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_sampler_ycbcr_conversion" number="157" type="device" requires="VK_KHR_maintenance1,VK_KHR_bind_memory2,VK_KHR_get_memory_requirements2,VK_KHR_get_physical_device_properties2" author="KHR" contact="Andrew Garrard @fluppeteer" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="14" name="VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION"/>
- <enum value=""VK_KHR_sampler_ycbcr_conversion"" name="VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR" alias="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR" alias="VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR" alias="VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"/>
- <enum extends="VkDebugReportObjectTypeEXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT" alias="VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT"/>
- <enum extends="VkObjectType" name="VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR" alias="VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"/>
- <enum extends="VkFormat" name="VK_FORMAT_G8B8G8R8_422_UNORM_KHR" alias="VK_FORMAT_G8B8G8R8_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_B8G8R8G8_422_UNORM_KHR" alias="VK_FORMAT_B8G8R8G8_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR" alias="VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR" alias="VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR" alias="VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR" alias="VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR" alias="VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_R10X6_UNORM_PACK16_KHR" alias="VK_FORMAT_R10X6_UNORM_PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR" alias="VK_FORMAT_R10X6G10X6_UNORM_2PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR" alias="VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR" alias="VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR" alias="VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR" alias="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR" alias="VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR" alias="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR" alias="VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR" alias="VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_R12X4_UNORM_PACK16_KHR" alias="VK_FORMAT_R12X4_UNORM_PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR" alias="VK_FORMAT_R12X4G12X4_UNORM_2PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR" alias="VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR" alias="VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR" alias="VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR" alias="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR" alias="VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR" alias="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR" alias="VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR" alias="VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"/>
- <enum extends="VkFormat" name="VK_FORMAT_G16B16G16R16_422_UNORM_KHR" alias="VK_FORMAT_G16B16G16R16_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_B16G16R16G16_422_UNORM_KHR" alias="VK_FORMAT_B16G16R16G16_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR" alias="VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR" alias="VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR" alias="VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR" alias="VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"/>
- <enum extends="VkFormat" name="VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR" alias="VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"/>
- <enum extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_PLANE_0_BIT_KHR" alias="VK_IMAGE_ASPECT_PLANE_0_BIT"/>
- <enum extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_PLANE_1_BIT_KHR" alias="VK_IMAGE_ASPECT_PLANE_1_BIT"/>
- <enum extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_PLANE_2_BIT_KHR" alias="VK_IMAGE_ASPECT_PLANE_2_BIT"/>
- <enum extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_DISJOINT_BIT_KHR" alias="VK_IMAGE_CREATE_DISJOINT_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR" alias="VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR" alias="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR" alias="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR" alias="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR" alias="VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_DISJOINT_BIT_KHR" alias="VK_FORMAT_FEATURE_DISJOINT_BIT"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR" alias="VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"/>
- <type name="VkSamplerYcbcrConversionCreateInfoKHR"/>
- <type name="VkSamplerYcbcrConversionInfoKHR"/>
- <type name="VkBindImagePlaneMemoryInfoKHR"/>
- <type name="VkImagePlaneMemoryRequirementsInfoKHR"/>
- <type name="VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR"/>
- <type name="VkSamplerYcbcrConversionImageFormatPropertiesKHR"/>
- <command name="vkCreateSamplerYcbcrConversionKHR"/>
- <command name="vkDestroySamplerYcbcrConversionKHR"/>
- <type name="VkSamplerYcbcrConversionKHR"/>
- <type name="VkSamplerYcbcrModelConversionKHR"/>
- <enum extends="VkSamplerYcbcrModelConversion" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR" alias="VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY"/>
- <enum extends="VkSamplerYcbcrModelConversion" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR" alias="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY"/>
- <enum extends="VkSamplerYcbcrModelConversion" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR" alias="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709"/>
- <enum extends="VkSamplerYcbcrModelConversion" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR" alias="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601"/>
- <enum extends="VkSamplerYcbcrModelConversion" name="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR" alias="VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020"/>
- <type name="VkSamplerYcbcrRangeKHR"/>
- <enum extends="VkSamplerYcbcrRange" name="VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR" alias="VK_SAMPLER_YCBCR_RANGE_ITU_FULL"/>
- <enum extends="VkSamplerYcbcrRange" name="VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR" alias="VK_SAMPLER_YCBCR_RANGE_ITU_NARROW"/>
- <type name="VkChromaLocationKHR"/>
- <enum extends="VkChromaLocation" name="VK_CHROMA_LOCATION_COSITED_EVEN_KHR" alias="VK_CHROMA_LOCATION_COSITED_EVEN"/>
- <enum extends="VkChromaLocation" name="VK_CHROMA_LOCATION_MIDPOINT_KHR" alias="VK_CHROMA_LOCATION_MIDPOINT"/>
- </require>
- <require extension="VK_EXT_debug_report">
- <enum extends="VkDebugReportObjectTypeEXT" offset="0" name="VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_bind_memory2" number="158" type="device" author="KHR" contact="Tobias Hector @tobski" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_BIND_MEMORY_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_bind_memory2"" name="VK_KHR_BIND_MEMORY_2_EXTENSION_NAME"/>
- <command name="vkBindBufferMemory2KHR"/>
- <command name="vkBindImageMemory2KHR"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR" alias="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR" alias="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"/>
- <enum extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_ALIAS_BIT_KHR" alias="VK_IMAGE_CREATE_ALIAS_BIT"/>
- <type name="VkBindBufferMemoryInfoKHR"/>
- <type name="VkBindImageMemoryInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_image_drm_format_modifier" number="159" type="device" requires="VK_KHR_bind_memory2,VK_KHR_get_physical_device_properties2,VK_KHR_image_format_list,VK_KHR_sampler_ycbcr_conversion" author="EXT" contact="Chad Versace @chadversary" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION"/>
- <enum value=""VK_EXT_image_drm_format_modifier"" name="VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME"/>
- <enum offset="0" dir="-" extends="VkResult" name="VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"/>
- <enum offset="0" extends="VkImageTiling" name="VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT"/>
- <enum bitpos="7" extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"/>
- <enum bitpos="8" extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"/>
- <enum bitpos="9" extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"/>
- <enum bitpos="10" extends="VkImageAspectFlagBits" name="VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"/>
- <type name="VkDrmFormatModifierPropertiesListEXT"/>
- <type name="VkDrmFormatModifierPropertiesEXT"/>
- <type name="VkPhysicalDeviceImageDrmFormatModifierInfoEXT"/>
- <type name="VkImageDrmFormatModifierListCreateInfoEXT"/>
- <type name="VkImageDrmFormatModifierExplicitCreateInfoEXT"/>
- <type name="VkImageDrmFormatModifierPropertiesEXT"/>
- <command name="vkGetImageDrmFormatModifierPropertiesEXT"/>
- </require>
- <require extension="VK_KHR_format_feature_flags2">
- <type name="VkDrmFormatModifierPropertiesList2EXT"/>
- <type name="VkDrmFormatModifierProperties2EXT"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_160" number="160" author="EXT" contact="Mark Young @marky-lunarg" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_160_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_160"" name="VK_EXT_EXTENSION_160_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_validation_cache" number="161" type="device" author="GOOGLE" contact="Cort Stratton @cdwfs" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_VALIDATION_CACHE_SPEC_VERSION"/>
- <enum value=""VK_EXT_validation_cache"" name="VK_EXT_VALIDATION_CACHE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"/>
- <type name="VkValidationCacheEXT"/>
- <type name="VkValidationCacheCreateInfoEXT"/>
- <type name="VkShaderModuleValidationCacheCreateInfoEXT"/>
- <type name="VkValidationCacheHeaderVersionEXT"/>
- <type name="VkValidationCacheCreateFlagsEXT"/>
- <command name="vkCreateValidationCacheEXT"/>
- <command name="vkDestroyValidationCacheEXT"/>
- <command name="vkMergeValidationCachesEXT"/>
- <command name="vkGetValidationCacheDataEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_descriptor_indexing" number="162" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_maintenance3" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="2" name="VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION"/>
- <enum value=""VK_EXT_descriptor_indexing"" name="VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT" alias="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT" alias="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT" alias="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"/>
- <enum extends="VkDescriptorBindingFlagBits" name="VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT" alias="VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"/>
- <enum extends="VkDescriptorBindingFlagBits" name="VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT" alias="VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"/>
- <enum extends="VkDescriptorBindingFlagBits" name="VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT" alias="VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"/>
- <enum extends="VkDescriptorBindingFlagBits" name="VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT" alias="VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"/>
- <enum extends="VkDescriptorPoolCreateFlagBits" name="VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT" alias="VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"/>
- <enum extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT" alias="VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"/>
- <enum extends="VkResult" name="VK_ERROR_FRAGMENTATION_EXT" alias="VK_ERROR_FRAGMENTATION"/>
- <type name="VkDescriptorSetLayoutBindingFlagsCreateInfoEXT"/>
- <type name="VkPhysicalDeviceDescriptorIndexingFeaturesEXT"/>
- <type name="VkPhysicalDeviceDescriptorIndexingPropertiesEXT"/>
- <type name="VkDescriptorSetVariableDescriptorCountAllocateInfoEXT"/>
- <type name="VkDescriptorSetVariableDescriptorCountLayoutSupportEXT"/>
- <type name="VkDescriptorBindingFlagBitsEXT"/>
- <type name="VkDescriptorBindingFlagsEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_viewport_index_layer" number="163" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_viewport_index_layer"" name="VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_portability_subset" number="164" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Bill Hollings @billhollings" platform="provisional" supported="vulkan" provisional="true">
- <require>
- <enum value="1" name="VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION"/>
- <enum value=""VK_KHR_portability_subset"" name="VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <type name="VkPhysicalDevicePortabilitySubsetFeaturesKHR"/>
- <type name="VkPhysicalDevicePortabilitySubsetPropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_NV_shading_rate_image" number="165" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
- <require>
- <enum value="3" name="VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION"/>
- <enum value=""VK_NV_shading_rate_image"" name="VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"/>
- <enum extends="VkImageLayout" name="VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV" alias="VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"/>
- <enum offset="4" extends="VkDynamicState" name="VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV"/>
- <enum extends="VkAccessFlagBits" name="VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV" alias="VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"/>
- <enum extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV" alias="VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- <enum extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" alias="VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"/>
- <enum offset="6" extends="VkDynamicState" name="VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV"/>
- <type name="VkShadingRatePaletteEntryNV"/>
- <type name="VkShadingRatePaletteNV"/>
- <type name="VkPipelineViewportShadingRateImageStateCreateInfoNV"/>
- <type name="VkPhysicalDeviceShadingRateImageFeaturesNV"/>
- <type name="VkPhysicalDeviceShadingRateImagePropertiesNV"/>
- <type name="VkCoarseSampleLocationNV"/>
- <type name="VkCoarseSampleOrderCustomNV"/>
- <type name="VkPipelineViewportCoarseSampleOrderStateCreateInfoNV"/>
- <type name="VkCoarseSampleOrderTypeNV"/>
- <command name="vkCmdBindShadingRateImageNV"/>
- <command name="vkCmdSetViewportShadingRatePaletteNV"/>
- <command name="vkCmdSetCoarseSampleOrderNV"/>
- </require>
- </extension>
- <extension name="VK_NV_ray_tracing" number="166" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_get_memory_requirements2" author="NV" contact="Eric Werness @ewerness-nv" supported="vulkan">
- <require>
- <enum value="3" name="VK_NV_RAY_TRACING_SPEC_VERSION"/>
- <enum value=""VK_NV_ray_tracing"" name="VK_NV_RAY_TRACING_EXTENSION_NAME"/>
- <enum name="VK_SHADER_UNUSED_NV"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_GEOMETRY_NV"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"/>
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"/>
- <enum offset="11" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"/>
- <enum offset="12" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV"/>
- <enum extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_RAYGEN_BIT_NV" alias="VK_SHADER_STAGE_RAYGEN_BIT_KHR"/>
- <enum extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_ANY_HIT_BIT_NV" alias="VK_SHADER_STAGE_ANY_HIT_BIT_KHR"/>
- <enum extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV" alias="VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"/>
- <enum extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_MISS_BIT_NV" alias="VK_SHADER_STAGE_MISS_BIT_KHR"/>
- <enum extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_INTERSECTION_BIT_NV" alias="VK_SHADER_STAGE_INTERSECTION_BIT_KHR"/>
- <enum extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_CALLABLE_BIT_NV" alias="VK_SHADER_STAGE_CALLABLE_BIT_KHR"/>
- <enum extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV" alias="VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"/>
- <enum extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV" alias="VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"/>
- <enum extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RAY_TRACING_BIT_NV" alias="VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"/>
- <enum extends="VkPipelineBindPoint" name="VK_PIPELINE_BIND_POINT_RAY_TRACING_NV" alias="VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"/>
- <enum offset="0" extends="VkDescriptorType" name="VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV"/>
- <enum extends="VkAccessFlagBits" name="VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV" alias="VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"/>
- <enum extends="VkAccessFlagBits" name="VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV" alias="VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"/>
- <enum offset="0" extends="VkQueryType" name="VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV"/>
- <enum bitpos="5" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"/>
- <enum offset="0" extends="VkDebugReportObjectTypeEXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT"/>
- <enum extends="VkIndexType" name="VK_INDEX_TYPE_NONE_NV" alias="VK_INDEX_TYPE_NONE_KHR"/>
- <type name="VkRayTracingShaderGroupCreateInfoNV"/>
- <type name="VkRayTracingShaderGroupTypeNV"/>
- <enum extends="VkRayTracingShaderGroupTypeKHR" name="VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV" alias="VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR"/>
- <enum extends="VkRayTracingShaderGroupTypeKHR" name="VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV" alias="VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR"/>
- <enum extends="VkRayTracingShaderGroupTypeKHR" name="VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV" alias="VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR"/>
- <type name="VkRayTracingPipelineCreateInfoNV"/>
- <type name="VkGeometryTypeNV"/>
- <enum extends="VkGeometryTypeKHR" name="VK_GEOMETRY_TYPE_TRIANGLES_NV" alias="VK_GEOMETRY_TYPE_TRIANGLES_KHR"/>
- <enum extends="VkGeometryTypeKHR" name="VK_GEOMETRY_TYPE_AABBS_NV" alias="VK_GEOMETRY_TYPE_AABBS_KHR"/>
- <type name="VkAccelerationStructureTypeNV"/>
- <enum extends="VkAccelerationStructureTypeKHR" name="VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV" alias="VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR"/>
- <enum extends="VkAccelerationStructureTypeKHR" name="VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV" alias="VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR"/>
- <type name="VkGeometryTrianglesNV"/>
- <type name="VkGeometryAABBNV"/>
- <type name="VkGeometryDataNV"/>
- <type name="VkGeometryNV"/>
- <type name="VkGeometryFlagsNV"/>
- <type name="VkGeometryFlagBitsNV"/>
- <enum extends="VkGeometryFlagBitsKHR" name="VK_GEOMETRY_OPAQUE_BIT_NV" alias="VK_GEOMETRY_OPAQUE_BIT_KHR"/>
- <enum extends="VkGeometryFlagBitsKHR" name="VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV" alias="VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR"/>
- <type name="VkGeometryInstanceFlagsNV"/>
- <type name="VkGeometryInstanceFlagBitsNV"/>
- <enum extends="VkGeometryInstanceFlagBitsKHR" name="VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV" alias="VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR"/>
- <enum extends="VkGeometryInstanceFlagBitsKHR" name="VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV" alias="VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR"/>
- <enum extends="VkGeometryInstanceFlagBitsKHR" name="VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV" alias="VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR"/>
- <enum extends="VkGeometryInstanceFlagBitsKHR" name="VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV" alias="VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR"/>
- <type name="VkAccelerationStructureInfoNV"/>
- <type name="VkAccelerationStructureCreateInfoNV"/>
- <type name="VkAccelerationStructureNV"/>
- <type name="VkBuildAccelerationStructureFlagBitsNV"/>
- <enum extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV" alias="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR"/>
- <enum extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV" alias="VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR"/>
- <enum extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV" alias="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR"/>
- <enum extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV" alias="VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR"/>
- <enum extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV" alias="VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR"/>
- <type name="VkBuildAccelerationStructureFlagsNV"/>
- <type name="VkCopyAccelerationStructureModeNV"/>
- <enum extends="VkCopyAccelerationStructureModeKHR" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV" alias="VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR"/>
- <enum extends="VkCopyAccelerationStructureModeKHR" name="VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV" alias="VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR"/>
- <type name="VkBindAccelerationStructureMemoryInfoNV"/>
- <type name="VkWriteDescriptorSetAccelerationStructureNV"/>
- <type name="VkAccelerationStructureMemoryRequirementsInfoNV"/>
- <type name="VkPhysicalDeviceRayTracingPropertiesNV"/>
- <type name="VkMemoryRequirements2KHR"/>
- <type name="VkAccelerationStructureMemoryRequirementsTypeNV"/>
- <type name="VkTransformMatrixNV"/>
- <type name="VkAabbPositionsNV"/>
- <type name="VkAccelerationStructureInstanceNV"/>
- <command name="vkCreateAccelerationStructureNV"/>
- <command name="vkDestroyAccelerationStructureNV"/>
- <command name="vkGetAccelerationStructureMemoryRequirementsNV"/>
- <command name="vkBindAccelerationStructureMemoryNV"/>
- <command name="vkCmdBuildAccelerationStructureNV"/>
- <command name="vkCmdCopyAccelerationStructureNV"/>
- <command name="vkCmdTraceRaysNV"/>
- <command name="vkCreateRayTracingPipelinesNV"/>
- <command name="vkGetRayTracingShaderGroupHandlesNV"/>
- <command name="vkGetAccelerationStructureHandleNV"/>
- <command name="vkCmdWriteAccelerationStructuresPropertiesNV"/>
- <command name="vkCompileDeferredNV"/>
- </require>
- </extension>
- <extension name="VK_NV_representative_fragment_test" number="167" type="device" author="NV" contact="Kedarnath Thangudu @kthangudu" supported="vulkan">
- <require>
- <enum value="2" name="VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION"/>
- <enum value=""VK_NV_representative_fragment_test"" name="VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"/>
- <type name="VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV"/>
- <type name="VkPipelineRepresentativeFragmentTestStateCreateInfoNV"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_168" number="168" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_168_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_168"" name="VK_NV_EXTENSION_168_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_maintenance3" number="169" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_1">
- <require>
- <enum value="1" name="VK_KHR_MAINTENANCE_3_SPEC_VERSION"/>
- <enum value=""VK_KHR_maintenance3"" name="VK_KHR_MAINTENANCE_3_EXTENSION_NAME"/>
- <enum alias="VK_KHR_MAINTENANCE_3_SPEC_VERSION" name="VK_KHR_MAINTENANCE3_SPEC_VERSION" comment="Backwards-compatible alias containing a typo"/>
- <enum alias="VK_KHR_MAINTENANCE_3_EXTENSION_NAME" name="VK_KHR_MAINTENANCE3_EXTENSION_NAME" comment="Backwards-compatible alias containing a typo"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR" alias="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"/>
- <type name="VkPhysicalDeviceMaintenance3PropertiesKHR"/>
- <type name="VkDescriptorSetLayoutSupportKHR"/>
- <command name="vkGetDescriptorSetLayoutSupportKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_draw_indirect_count" number="170" type="device" author="KHR" contact="Piers Daniell @pdaniell-nv" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION"/>
- <enum value=""VK_KHR_draw_indirect_count"" name="VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME"/>
- <command name="vkCmdDrawIndirectCountKHR"/>
- <command name="vkCmdDrawIndexedIndirectCountKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_filter_cubic" number="171" type="device" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="vulkan">
- <require>
- <enum value="3" name="VK_EXT_FILTER_CUBIC_SPEC_VERSION"/>
- <enum value=""VK_EXT_filter_cubic"" name="VK_EXT_FILTER_CUBIC_EXTENSION_NAME"/>
- <enum extends="VkFilter" name="VK_FILTER_CUBIC_EXT" alias="VK_FILTER_CUBIC_IMG"/>
- <enum extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" alias="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"/>
- <type name="VkPhysicalDeviceImageViewImageFormatInfoEXT"/>
- <type name="VkFilterCubicImageViewImageFormatPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_QCOM_render_pass_shader_resolve" number="172" type="device" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="vulkan">
- <require>
- <enum value="4" name="VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION"/>
- <enum value=""VK_QCOM_render_pass_shader_resolve"" name="VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME"/>
- <enum bitpos="2" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM"/>
- <enum bitpos="3" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_173" number="173" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_173_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_173"" name="VK_QCOM_EXTENSION_173_EXTENSION_NAME"/>
- <enum bitpos="18" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM"/>
- <enum bitpos="16" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM"/>
- <enum bitpos="17" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_174" number="174" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_174_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_174"" name="VK_QCOM_EXTENSION_174_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_global_priority" number="175" type="device" author="EXT" contact="Andres Rodriguez @lostgoat" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION"/>
- <enum value=""VK_EXT_global_priority"" name="VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT"/>
- <enum offset="1" dir="-" extends="VkResult" name="VK_ERROR_NOT_PERMITTED_EXT"/>
- <type name="VkDeviceQueueGlobalPriorityCreateInfoEXT"/>
- <type name="VkQueueGlobalPriorityEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_subgroup_extended_types" number="176" type="device" requiresCore="1.1" author="KHR" contact="Neil Henning @sheredom" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_subgroup_extended_types"" name="VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"/>
- <type name="VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_177" number="177" author="EXT" contact="Neil Henning @sheredom" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_177_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_177"" name="VK_EXT_EXTENSION_177_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_8bit_storage" number="178" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_storage_buffer_storage_class" author="KHR" contact="Alexander Galazin @alegal-arm" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_8BIT_STORAGE_SPEC_VERSION"/>
- <enum value=""VK_KHR_8bit_storage"" name="VK_KHR_8BIT_STORAGE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"/>
- <type name="VkPhysicalDevice8BitStorageFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_external_memory_host" number="179" type="device" author="EXT" requires="VK_KHR_external_memory" contact="Daniel Rakos @drakos-amd" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION"/>
- <enum value=""VK_EXT_external_memory_host"" name="VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"/>
- <enum bitpos="7" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"/>
- <enum bitpos="8" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"/>
- <type name="VkImportMemoryHostPointerInfoEXT"/>
- <type name="VkMemoryHostPointerPropertiesEXT"/>
- <type name="VkPhysicalDeviceExternalMemoryHostPropertiesEXT"/>
- <command name="vkGetMemoryHostPointerPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_AMD_buffer_marker" number="180" type="device" author="AMD" contact="Daniel Rakos @drakos-amd" specialuse="devtools" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_BUFFER_MARKER_SPEC_VERSION"/>
- <enum value=""VK_AMD_buffer_marker"" name="VK_AMD_BUFFER_MARKER_EXTENSION_NAME"/>
- <command name="vkCmdWriteBufferMarkerAMD"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_atomic_int64" number="181" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Aaron Hagan @ahagan" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_atomic_int64"" name="VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"/>
- <type name="VkPhysicalDeviceShaderAtomicInt64FeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_clock" number="182" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Aaron Hagan @ahagan" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SHADER_CLOCK_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_clock"" name="VK_KHR_SHADER_CLOCK_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"/>
- <type name="VkPhysicalDeviceShaderClockFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_183" number="183" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_183_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_183"" name="VK_AMD_EXTENSION_183_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_pipeline_compiler_control" number="184" type="device" author="AMD" contact="Matthaeus G. Chajdas @anteru" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION"/>
- <enum value=""VK_AMD_pipeline_compiler_control"" name="VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"/>
- <type name="VkPipelineCompilerControlFlagBitsAMD"/>
- <type name="VkPipelineCompilerControlFlagsAMD"/>
- <type name="VkPipelineCompilerControlCreateInfoAMD"/>
- </require>
- </extension>
- <extension name="VK_EXT_calibrated_timestamps" number="185" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Daniel Rakos @drakos-amd" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION"/>
- <enum value=""VK_EXT_calibrated_timestamps"" name="VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"/>
- <type name="VkTimeDomainEXT"/>
- <type name="VkCalibratedTimestampInfoEXT"/>
- <command name="vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"/>
- <command name="vkGetCalibratedTimestampsEXT"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_core_properties" number="186" type="device" author="AMD" requires="VK_KHR_get_physical_device_properties2" contact="Martin Dinkov @mdinkov" supported="vulkan">
- <require>
- <enum value="2" name="VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_core_properties"" name="VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"/>
- <type name="VkPhysicalDeviceShaderCorePropertiesAMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_187" number="187" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_187_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_187"" name="VK_AMD_EXTENSION_187_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_video_decode_h265" number="188" type="device" requires="VK_KHR_video_decode_queue" author="KHR" contact="[email protected]" provisional="true" platform="provisional" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION"/>
- <enum value=""VK_EXT_video_decode_h265"" name="VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="1" extends="VkVideoCodecOperationFlagBitsKHR" name="VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <type name="VkVideoDecodeH265CreateFlagsEXT"/>
- <type name="VkVideoDecodeH265ProfileEXT"/>
- <type name="VkVideoDecodeH265CapabilitiesEXT"/>
- <type name="VkVideoDecodeH265SessionCreateInfoEXT"/>
-
- <type name="VkVideoDecodeH265SessionParametersCreateInfoEXT"/>
- <type name="VkVideoDecodeH265SessionParametersAddInfoEXT"/>
- <type name="VkVideoDecodeH265PictureInfoEXT"/>
- <type name="VkVideoDecodeH265DpbSlotInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_189" number="189" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_189_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_189"" name="VK_AMD_EXTENSION_189_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_memory_overallocation_behavior" number="190" type="device" author="AMD" contact="Martin Dinkov @mdinkov" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION"/>
- <enum value=""VK_AMD_memory_overallocation_behavior"" name="VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"/>
- <type name="VkMemoryOverallocationBehaviorAMD"/>
- <type name="VkDeviceMemoryOverallocationCreateInfoAMD"/>
- </require>
- </extension>
- <extension name="VK_EXT_vertex_attribute_divisor" number="191" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Vikram Kushwaha @vkushwaha" supported="vulkan">
- <require>
- <enum value="3" name="VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION"/>
- <enum value=""VK_EXT_vertex_attribute_divisor"" name="VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT"/>
- <type name="VkVertexInputBindingDivisorDescriptionEXT"/>
- <type name="VkPipelineVertexInputDivisorStateCreateInfoEXT"/>
- <type name="VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_GGP_frame_token" number="192" type="device" requires="VK_KHR_swapchain,VK_GGP_stream_descriptor_surface" platform="ggp" author="GGP" contact="Jean-Francois Roy @jfroy" supported="vulkan">
- <require>
- <enum value="1" name="VK_GGP_FRAME_TOKEN_SPEC_VERSION"/>
- <enum value=""VK_GGP_frame_token"" name="VK_GGP_FRAME_TOKEN_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"/>
- <type name="VkPresentFrameTokenGGP"/>
- </require>
- </extension>
- <extension name="VK_EXT_pipeline_creation_feedback" number="193" type="device" author="GOOGLE" contact="Jean-Francois Roy @jfroy" specialuse="devtools" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION"/>
- <enum value=""VK_EXT_pipeline_creation_feedback"" name="VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT"/>
- <type name="VkPipelineCreationFeedbackFlagBitsEXT"/>
- <type name="VkPipelineCreationFeedbackFlagsEXT"/>
- <type name="VkPipelineCreationFeedbackCreateInfoEXT"/>
- <type name="VkPipelineCreationFeedbackEXT"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_extension_194" number="194" author="GOOGLE" contact="Jean-Francois Roy @jfroy" supported="disabled">
- <require>
- <enum value="0" name="VK_GOOGLE_EXTENSION_194_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_extension_194"" name="VK_GOOGLE_EXTENSION_194_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_extension_195" number="195" author="GOOGLE" contact="Jean-Francois Roy @jfroy" supported="disabled">
- <require>
- <enum value="0" name="VK_GOOGLE_EXTENSION_195_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_extension_195"" name="VK_GOOGLE_EXTENSION_195_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_extension_196" number="196" author="GOOGLE" contact="Jean-Francois Roy @jfroy" supported="disabled">
- <require>
- <enum value="0" name="VK_GOOGLE_EXTENSION_196_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_extension_196"" name="VK_GOOGLE_EXTENSION_196_EXTENSION_NAME"/>
- <enum bitpos="1" extends="VkPipelineCacheCreateFlagBits"
- name="VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_driver_properties" number="197" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Daniel Rakos @drakos-amd" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION"/>
- <enum value=""VK_KHR_driver_properties"" name="VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"/>
- <enum name="VK_MAX_DRIVER_NAME_SIZE_KHR"/>
- <enum name="VK_MAX_DRIVER_INFO_SIZE_KHR"/>
- <type name="VkDriverIdKHR"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_AMD_PROPRIETARY_KHR" alias="VK_DRIVER_ID_AMD_PROPRIETARY"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR" alias="VK_DRIVER_ID_AMD_OPEN_SOURCE"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_MESA_RADV_KHR" alias="VK_DRIVER_ID_MESA_RADV"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR" alias="VK_DRIVER_ID_NVIDIA_PROPRIETARY"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR" alias="VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR" alias="VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR" alias="VK_DRIVER_ID_IMAGINATION_PROPRIETARY"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR" alias="VK_DRIVER_ID_QUALCOMM_PROPRIETARY"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_ARM_PROPRIETARY_KHR" alias="VK_DRIVER_ID_ARM_PROPRIETARY"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR" alias="VK_DRIVER_ID_GOOGLE_SWIFTSHADER"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_GGP_PROPRIETARY_KHR" alias="VK_DRIVER_ID_GGP_PROPRIETARY"/>
- <enum extends="VkDriverId" name="VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR" alias="VK_DRIVER_ID_BROADCOM_PROPRIETARY"/>
- <type name="VkConformanceVersionKHR"/>
- <type name="VkPhysicalDeviceDriverPropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_float_controls" number="198" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Alexander Galazin @alegal-arm" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="4" name="VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_float_controls"" name="VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"/>
- <type name="VkPhysicalDeviceFloatControlsPropertiesKHR"/>
- <type name="VkShaderFloatControlsIndependenceKHR"/>
- <enum extends="VkShaderFloatControlsIndependence" name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR" alias="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"/>
- <enum extends="VkShaderFloatControlsIndependence" name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR" alias="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"/>
- <enum extends="VkShaderFloatControlsIndependence" name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR" alias="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"/>
- </require>
- </extension>
- <extension name="VK_NV_shader_subgroup_partitioned" number="199" type="device" requiresCore="1.1" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION"/>
- <enum value=""VK_NV_shader_subgroup_partitioned"" name="VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME"/>
- <enum bitpos="8" extends="VkSubgroupFeatureFlagBits" name="VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"/>
- </require>
- </extension>
- <extension name="VK_KHR_depth_stencil_resolve" number="200" type="device" requires="VK_KHR_create_renderpass2" author="KHR" contact="Jan-Harald Fredriksen @janharald" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION"/>
- <enum value=""VK_KHR_depth_stencil_resolve"" name="VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR" alias="VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"/>
- <type name="VkSubpassDescriptionDepthStencilResolveKHR"/>
- <type name="VkPhysicalDeviceDepthStencilResolvePropertiesKHR"/>
- <type name="VkResolveModeFlagBitsKHR"/>
- <type name="VkResolveModeFlagsKHR"/>
- <enum extends="VkResolveModeFlagBits" name="VK_RESOLVE_MODE_NONE_KHR" alias="VK_RESOLVE_MODE_NONE"/>
- <enum extends="VkResolveModeFlagBits" name="VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR" alias="VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"/>
- <enum extends="VkResolveModeFlagBits" name="VK_RESOLVE_MODE_AVERAGE_BIT_KHR" alias="VK_RESOLVE_MODE_AVERAGE_BIT"/>
- <enum extends="VkResolveModeFlagBits" name="VK_RESOLVE_MODE_MIN_BIT_KHR" alias="VK_RESOLVE_MODE_MIN_BIT"/>
- <enum extends="VkResolveModeFlagBits" name="VK_RESOLVE_MODE_MAX_BIT_KHR" alias="VK_RESOLVE_MODE_MAX_BIT"/>
- </require>
- </extension>
- <extension name="VK_KHR_swapchain_mutable_format" number="201" type="device" author="KHR" requires="VK_KHR_swapchain,VK_KHR_maintenance2,VK_KHR_image_format_list" contact="Daniel Rakos @drakos-arm" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION"/>
- <enum value=""VK_KHR_swapchain_mutable_format"" name="VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME"/>
- <enum bitpos="2" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"/>
- </require>
- </extension>
- <extension name="VK_NV_compute_shader_derivatives" number="202" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION"/>
- <enum value=""VK_NV_compute_shader_derivatives"" name="VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"/>
- <type name="VkPhysicalDeviceComputeShaderDerivativesFeaturesNV"/>
- </require>
- </extension>
- <extension name="VK_NV_mesh_shader" number="203" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_MESH_SHADER_SPEC_VERSION"/>
- <enum value=""VK_NV_mesh_shader"" name="VK_NV_MESH_SHADER_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"/>
- <enum bitpos="6" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_TASK_BIT_NV"/>
- <enum bitpos="7" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_MESH_BIT_NV"/>
- <enum bitpos="19" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV"/>
- <enum bitpos="20" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV"/>
- <command name="vkCmdDrawMeshTasksNV"/>
- <command name="vkCmdDrawMeshTasksIndirectNV"/>
- <command name="vkCmdDrawMeshTasksIndirectCountNV"/>
- <type name="VkPhysicalDeviceMeshShaderFeaturesNV"/>
- <type name="VkPhysicalDeviceMeshShaderPropertiesNV"/>
- <type name="VkDrawMeshTasksIndirectCommandNV"/>
- </require>
- </extension>
- <extension name="VK_NV_fragment_shader_barycentric" number="204" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION"/>
- <enum value=""VK_NV_fragment_shader_barycentric"" name="VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"/>
- <type name="VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV"/>
- </require>
- </extension>
- <extension name="VK_NV_shader_image_footprint" number="205" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
- <require>
- <enum value="2" name="VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION"/>
- <enum value=""VK_NV_shader_image_footprint"" name="VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"/>
- <type name="VkPhysicalDeviceShaderImageFootprintFeaturesNV"/>
- </require>
- </extension>
- <extension name="VK_NV_scissor_exclusive" number="206" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION"/>
- <enum value=""VK_NV_scissor_exclusive"" name="VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"/>
- <enum offset="1" extends="VkDynamicState" name="VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"/>
- <type name="VkPipelineViewportExclusiveScissorStateCreateInfoNV"/>
- <type name="VkPhysicalDeviceExclusiveScissorFeaturesNV"/>
- <command name="vkCmdSetExclusiveScissorNV"/>
- </require>
- </extension>
- <extension name="VK_NV_device_diagnostic_checkpoints" type="device" number="207" requires="VK_KHR_get_physical_device_properties2" author="NVIDIA" contact="Nuno Subtil @nsubtil" supported="vulkan">
- <require>
- <enum value="2" name="VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION"/>
- <enum value=""VK_NV_device_diagnostic_checkpoints"" name="VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"/>
- <type name="VkQueueFamilyCheckpointPropertiesNV"/>
- <type name="VkCheckpointDataNV"/>
- <command name="vkCmdSetCheckpointNV"/>
- <command name="vkGetQueueCheckpointDataNV"/>
- </require>
- </extension>
- <extension name="VK_KHR_timeline_semaphore" number="208" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jason Ekstrand @jekstrand" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="2" name="VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION"/>
- <enum value=""VK_KHR_timeline_semaphore"" name="VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR" alias="VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR" alias="VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR" alias="VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"/>
- <enum extends="VkSemaphoreType" name="VK_SEMAPHORE_TYPE_BINARY_KHR" alias="VK_SEMAPHORE_TYPE_BINARY"/>
- <enum extends="VkSemaphoreType" name="VK_SEMAPHORE_TYPE_TIMELINE_KHR" alias="VK_SEMAPHORE_TYPE_TIMELINE"/>
- <enum extends="VkSemaphoreWaitFlagBits" name="VK_SEMAPHORE_WAIT_ANY_BIT_KHR" alias="VK_SEMAPHORE_WAIT_ANY_BIT"/>
- <type name="VkSemaphoreTypeKHR"/>
- <type name="VkPhysicalDeviceTimelineSemaphoreFeaturesKHR"/>
- <type name="VkPhysicalDeviceTimelineSemaphorePropertiesKHR"/>
- <type name="VkSemaphoreTypeCreateInfoKHR"/>
- <type name="VkTimelineSemaphoreSubmitInfoKHR"/>
- <type name="VkSemaphoreWaitFlagBitsKHR"/>
- <type name="VkSemaphoreWaitFlagsKHR"/>
- <type name="VkSemaphoreWaitInfoKHR"/>
- <type name="VkSemaphoreSignalInfoKHR"/>
- <command name="vkGetSemaphoreCounterValueKHR"/>
- <command name="vkWaitSemaphoresKHR"/>
- <command name="vkSignalSemaphoreKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_209" number="209" type="device" author="KHR" contact="Ian Elliott @ianelliott" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_209_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_209"" name="VK_KHR_EXTENSION_209_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_INTEL_shader_integer_functions2" number="210" type="device" requires="VK_KHR_get_physical_device_properties2" author="INTEL" contact="Ian Romanick @ianromanick" supported="vulkan">
- <require>
- <enum value="1" name="VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION"/>
- <enum value=""VK_INTEL_shader_integer_functions2"" name="VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"/>
- <type name="VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"/>
- </require>
- </extension>
- <extension name="VK_INTEL_performance_query" number="211" type="device" author="INTEL" contact="Lionel Landwerlin @llandwerlin" specialuse="devtools" supported="vulkan">
- <require>
- <enum value="2" name="VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION"/>
- <enum value=""VK_INTEL_performance_query"" name="VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL" alias="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL" comment="Backwards-compatible alias"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"/>
- <enum offset="0" extends="VkQueryType" name="VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"/>
- <type name="VkPerformanceConfigurationTypeINTEL"/>
- <type name="VkQueryPoolSamplingModeINTEL"/>
- <type name="VkPerformanceOverrideTypeINTEL"/>
- <type name="VkPerformanceParameterTypeINTEL"/>
- <type name="VkPerformanceValueTypeINTEL"/>
- <type name="VkPerformanceValueDataINTEL"/>
- <type name="VkPerformanceValueINTEL"/>
- <type name="VkInitializePerformanceApiInfoINTEL"/>
- <type name="VkQueryPoolCreateInfoINTEL"/>
- <type name="VkQueryPoolPerformanceQueryCreateInfoINTEL"/>
- <type name="VkPerformanceMarkerInfoINTEL"/>
- <type name="VkPerformanceStreamMarkerInfoINTEL"/>
- <type name="VkPerformanceOverrideInfoINTEL"/>
- <type name="VkPerformanceConfigurationAcquireInfoINTEL"/>
- <type name="VkPerformanceConfigurationINTEL"/>
- <command name="vkInitializePerformanceApiINTEL"/>
- <command name="vkUninitializePerformanceApiINTEL"/>
- <command name="vkCmdSetPerformanceMarkerINTEL"/>
- <command name="vkCmdSetPerformanceStreamMarkerINTEL"/>
- <command name="vkCmdSetPerformanceOverrideINTEL"/>
- <command name="vkAcquirePerformanceConfigurationINTEL"/>
- <command name="vkReleasePerformanceConfigurationINTEL"/>
- <command name="vkQueueSetPerformanceConfigurationINTEL"/>
- <command name="vkGetPerformanceParameterINTEL"/>
- </require>
- </extension>
- <extension name="VK_KHR_vulkan_memory_model" number="212" type="device" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="3" name="VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION"/>
- <enum value=""VK_KHR_vulkan_memory_model"" name="VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"/>
- <type name="VkPhysicalDeviceVulkanMemoryModelFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_pci_bus_info" number="213" type="device" author="EXT" requires="VK_KHR_get_physical_device_properties2" contact="Matthaeus G. Chajdas @anteru" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_PCI_BUS_INFO_SPEC_VERSION"/>
- <enum value=""VK_EXT_pci_bus_info"" name="VK_EXT_PCI_BUS_INFO_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"/>
- <type name="VkPhysicalDevicePCIBusInfoPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_AMD_display_native_hdr" number="214" type="device" author="AMD" requires="VK_KHR_get_physical_device_properties2,VK_KHR_get_surface_capabilities2,VK_KHR_swapchain" contact="Matthaeus G. Chajdas @anteru" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION"/>
- <enum value=""VK_AMD_display_native_hdr"" name="VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"/>
- <enum offset="0" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DISPLAY_NATIVE_AMD"/>
- <type name="VkDisplayNativeHdrSurfaceCapabilitiesAMD"/>
- <type name="VkSwapchainDisplayNativeHdrCreateInfoAMD"/>
- <command name="vkSetLocalDimmingAMD"/>
- </require>
- </extension>
- <extension name="VK_FUCHSIA_imagepipe_surface" number="215" type="instance" author="FUCHSIA" requires="VK_KHR_surface" platform="fuchsia" contact="Craig Stout @cdotstout" supported="vulkan">
- <require>
- <enum value="1" name="VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_FUCHSIA_imagepipe_surface"" name="VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"/>
- <type name="VkImagePipeSurfaceCreateFlagsFUCHSIA"/>
- <type name="VkImagePipeSurfaceCreateInfoFUCHSIA"/>
- <command name="vkCreateImagePipeSurfaceFUCHSIA"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_terminate_invocation" number="216" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jesse Hall @critsec" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_terminate_invocation"" name="VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR"/>
- <type name="VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_extension_217" number="217" author="GOOGLE" contact="Jesse Hall @critsec" supported="disabled">
- <require>
- <enum value="0" name="VK_GOOGLE_EXTENSION_217_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_extension_217"" name="VK_GOOGLE_EXTENSION_217_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_metal_surface" number="218" type="instance" requires="VK_KHR_surface" platform="metal" supported="vulkan" author="EXT" contact="Dzmitry Malyshau @kvark">
- <require>
- <enum value="1" name="VK_EXT_METAL_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_EXT_metal_surface"" name="VK_EXT_METAL_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT"/>
- <type name="VkMetalSurfaceCreateFlagsEXT"/>
- <type name="VkMetalSurfaceCreateInfoEXT"/>
- <command name="vkCreateMetalSurfaceEXT"/>
- <type name="CAMetalLayer"/>
- </require>
- </extension>
- <extension name="VK_EXT_fragment_density_map" number="219" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Matthew Netsch @mnetsch" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION"/>
- <enum value=""VK_EXT_fragment_density_map"" name="VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"/>
- <enum bitpos="14" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"/>
- <enum offset="0" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"/>
- <enum bitpos="24" extends="VkAccessFlagBits" name="VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"/>
- <enum bitpos="24" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"/>
- <enum bitpos="9" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"/>
- <enum bitpos="0" extends="VkImageViewCreateFlagBits" name="VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT"/>
- <enum bitpos="23" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT"/>
- <enum bitpos="0" extends="VkSamplerCreateFlagBits" name="VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT"/>
- <enum bitpos="1" extends="VkSamplerCreateFlagBits" name="VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT"/>
- <type name="VkPhysicalDeviceFragmentDensityMapFeaturesEXT"/>
- <type name="VkPhysicalDeviceFragmentDensityMapPropertiesEXT"/>
- <type name="VkRenderPassFragmentDensityMapCreateInfoEXT"/>
- </require>
- <require extension="VK_KHR_format_feature_flags2">
- <enum bitpos="24" extends="VkFormatFeatureFlagBits2KHR" name="VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_220" number="220" author="EXT" contact="Dzmitry Malyshau @kvark" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_220_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_220"" name="VK_EXT_EXTENSION_220_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_221" number="221" author="KHR" contact="Tobias Hector @tobski" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_221_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_221"" name="VK_KHR_EXTENSION_221_EXTENSION_NAME"/>
- <enum bitpos="0" extends="VkRenderPassCreateFlagBits" name="VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_scalar_block_layout" number="222" requires="VK_KHR_get_physical_device_properties2" type="device" author="EXT" contact="Tobias Hector @tobski" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION"/>
- <enum value=""VK_EXT_scalar_block_layout"" name="VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME"/>
- <type name="VkPhysicalDeviceScalarBlockLayoutFeaturesEXT"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_223" number="223" author="EXT" contact="Tobias Hector @tobski" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_223_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_223"" name="VK_EXT_EXTENSION_223_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_hlsl_functionality1" number="224" type="device" author="GOOGLE" contact="Hai Nguyen @chaoticbob" supported="vulkan">
- <require>
- <enum value="1" name="VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_hlsl_functionality1"" name="VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME"/>
- <enum alias="VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION" name="VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION" comment="Backwards-compatible alias containing a typo"/>
- <enum alias="VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME" name="VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME" comment="Backwards-compatible alias containing a typo"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_decorate_string" number="225" type="device" author="GOOGLE" contact="Hai Nguyen @chaoticbob" supported="vulkan">
- <require>
- <enum value="1" name="VK_GOOGLE_DECORATE_STRING_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_decorate_string"" name="VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_subgroup_size_control" number="226" type="device" requiresCore="1.1" author="EXT" contact="Neil Henning @sheredom" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION"/>
- <enum value=""VK_EXT_subgroup_size_control"" name="VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME"/>
- <type name="VkPhysicalDeviceSubgroupSizeControlFeaturesEXT"/>
- <type name="VkPhysicalDeviceSubgroupSizeControlPropertiesEXT"/>
- <type name="VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"/>
- <enum bitpos="0" extends="VkPipelineShaderStageCreateFlagBits" name="VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"/>
- <enum bitpos="1" extends="VkPipelineShaderStageCreateFlagBits" name="VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_fragment_shading_rate" number="227" type="device" requires="VK_KHR_create_renderpass2,VK_KHR_get_physical_device_properties2" author="KHR" contact="Tobias Hector @tobski" supported="vulkan">
- <require>
- <enum value="2" name="VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION"/>
- <enum value=""VK_KHR_fragment_shading_rate"" name="VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME"/>
- <type name="VkFragmentShadingRateCombinerOpKHR"/>
- <type name="VkFragmentShadingRateAttachmentInfoKHR"/>
- <type name="VkPipelineFragmentShadingRateStateCreateInfoKHR"/>
- <type name="VkPhysicalDeviceFragmentShadingRateFeaturesKHR"/>
- <type name="VkPhysicalDeviceFragmentShadingRatePropertiesKHR"/>
- <type name="VkPhysicalDeviceFragmentShadingRateKHR"/>
- <command name="vkGetPhysicalDeviceFragmentShadingRatesKHR"/>
- <command name="vkCmdSetFragmentShadingRateKHR"/>
- <enum offset="3" extends="VkImageLayout" extnumber="165" name="VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"/>
- <enum bitpos="23" extends="VkAccessFlagBits" name="VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"/>
- <enum bitpos="8" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- <enum bitpos="22" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- <enum bitpos="30" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- </require>
- <require extension="VK_KHR_format_feature_flags2">
- <enum bitpos="30" extends="VkFormatFeatureFlagBits2KHR" name="VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- </require>
- </extension>
- <extension name="VK_AMD_shader_core_properties2" number="228" type="device" author="AMD" contact="Matthaeus G. Chajdas @anteru" supported="vulkan" requires="VK_AMD_shader_core_properties">
- <require>
- <enum value="1" name="VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION"/>
- <enum value=""VK_AMD_shader_core_properties2"" name="VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"/>
- <type name="VkPhysicalDeviceShaderCoreProperties2AMD"/>
- <type name="VkShaderCorePropertiesFlagBitsAMD"/>
- <type name="VkShaderCorePropertiesFlagsAMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_229" number="229" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_229_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_229"" name="VK_AMD_EXTENSION_229_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_device_coherent_memory" number="230" type="device" author="AMD" contact="Tobias Hector @tobski" supported="vulkan">
- <require>
- <enum value="1" name="VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION"/>
- <enum value=""VK_AMD_device_coherent_memory"" name="VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME"/>
- <enum bitpos="6" extends="VkMemoryPropertyFlagBits" name="VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"/>
- <enum bitpos="7" extends="VkMemoryPropertyFlagBits" name="VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"/>
- <type name="VkPhysicalDeviceCoherentMemoryFeaturesAMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_231" number="231" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_231_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_231"" name="VK_AMD_EXTENSION_231_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_232" number="232" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_232_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_232"" name="VK_AMD_EXTENSION_232_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_233" number="233" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_233_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_233"" name="VK_AMD_EXTENSION_233_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_234" number="234" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_234_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_234"" name="VK_AMD_EXTENSION_234_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_image_atomic_int64" number="235" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Tobias Hector @tobski" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_image_atomic_int64"" name="VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_236" number="236" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_236_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_236"" name="VK_AMD_EXTENSION_236_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_spirv_1_4" number="237" type="device" requiresCore="1.1" requires="VK_KHR_shader_float_controls" author="KHR" contact="Jesse Hall @critsec" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_SPIRV_1_4_SPEC_VERSION"/>
- <enum value=""VK_KHR_spirv_1_4"" name="VK_KHR_SPIRV_1_4_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_memory_budget" number="238" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_MEMORY_BUDGET_SPEC_VERSION"/>
- <enum value=""VK_EXT_memory_budget"" name="VK_EXT_MEMORY_BUDGET_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"/>
- <type name="VkPhysicalDeviceMemoryBudgetPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_memory_priority" number="239" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_MEMORY_PRIORITY_SPEC_VERSION"/>
- <enum value=""VK_EXT_memory_priority"" name="VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"/>
- <type name="VkPhysicalDeviceMemoryPriorityFeaturesEXT"/>
- <type name="VkMemoryPriorityAllocateInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_surface_protected_capabilities" number="240" type="instance" requiresCore="1.1" requires="VK_KHR_get_surface_capabilities2" author="KHR" contact="Sandeep Shinde @sashinde" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION"/>
- <enum value=""VK_KHR_surface_protected_capabilities"" name="VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR"/>
- <type name="VkSurfaceProtectedCapabilitiesKHR"/>
- </require>
- </extension>
- <extension name="VK_NV_dedicated_allocation_image_aliasing" number="241" type="device" requires="VK_KHR_dedicated_allocation" author="NVIDIA" contact="Nuno Subtil @nsubtil" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION"/>
- <enum value=""VK_NV_dedicated_allocation_image_aliasing"" name="VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"/>
- <type name="VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"/>
- </require>
- </extension>
- <extension name="VK_KHR_separate_depth_stencil_layouts" number="242" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_create_renderpass2" author="KHR" contact="Piers Daniell @pdaniell-nv" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION"/>
- <enum value=""VK_KHR_separate_depth_stencil_layouts"" name="VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR" alias="VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR" alias="VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"/>
- <enum extends="VkImageLayout" name="VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR" alias="VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"/>
- <enum extends="VkImageLayout" name="VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR" alias="VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"/>
- <enum extends="VkImageLayout" name="VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR" alias="VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"/>
- <enum extends="VkImageLayout" name="VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR" alias="VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"/>
- <type name="VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR"/>
- <type name="VkAttachmentReferenceStencilLayoutKHR"/>
- <type name="VkAttachmentDescriptionStencilLayoutKHR"/>
- </require>
- </extension>
- <extension name="VK_INTEL_extension_243" number="243" author="INTEL" contact="Slawek Grajewski @sgrajewski" supported="disabled">
- <require>
- <enum value="0" name="VK_INTEL_EXTENSION_243_SPEC_VERSION"/>
- <enum value=""VK_INTEL_extension_243"" name="VK_INTEL_EXTENSION_243_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_MESA_extension_244" number="244" author="MESA" contact="Andres Rodriguez @lostgoat" supported="disabled">
- <require>
- <enum value="0" name="VK_MESA_EXTENSION_244_SPEC_VERSION"/>
- <enum value=""VK_MESA_extension_244"" name="VK_MESA_EXTENSION_244_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_buffer_device_address" number="245" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Jeff Bolz @jeffbolznv" deprecatedby="VK_KHR_buffer_device_address" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION"/>
- <enum value=""VK_EXT_buffer_device_address"" name="VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT" alias="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"/>
- <enum extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT" alias="VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"/>
- <enum extends="VkBufferCreateFlagBits" name="VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT" alias="VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"/>
- <enum extends="VkResult" name="VK_ERROR_INVALID_DEVICE_ADDRESS_EXT" alias="VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"/>
- <type name="VkPhysicalDeviceBufferAddressFeaturesEXT"/>
- <type name="VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"/>
- <type name="VkBufferDeviceAddressInfoEXT"/>
- <type name="VkBufferDeviceAddressCreateInfoEXT"/>
- <command name="vkGetBufferDeviceAddressEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_tooling_info" number="246" type="device" author="EXT" contact="Tobias Hector @tobski" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_TOOLING_INFO_SPEC_VERSION"/>
- <enum value=""VK_EXT_tooling_info"" name="VK_EXT_TOOLING_INFO_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT"/>
- <type name="VkToolPurposeFlagBitsEXT"/>
- <type name="VkToolPurposeFlagsEXT"/>
- <type name="VkPhysicalDeviceToolPropertiesEXT"/>
- <command name="vkGetPhysicalDeviceToolPropertiesEXT"/>
- </require>
- <require extension="VK_EXT_debug_report">
- <enum bitpos="5" extends="VkToolPurposeFlagBitsEXT" name="VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT"/>
- </require>
- <require extension="VK_EXT_debug_marker">
- <enum bitpos="6" extends="VkToolPurposeFlagBitsEXT" name="VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT"/>
- </require>
- <require extension="VK_EXT_debug_utils">
- <enum bitpos="5" extends="VkToolPurposeFlagBitsEXT" name="VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT"/>
- <enum bitpos="6" extends="VkToolPurposeFlagBitsEXT" name="VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_separate_stencil_usage" number="247" type="device" author="EXT" contact="Daniel Rakos @drakos-amd" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION"/>
- <enum value=""VK_EXT_separate_stencil_usage"" name="VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT" alias="VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"/>
- <type name="VkImageStencilUsageCreateInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_validation_features" number="248" type="instance" author="LUNARG" contact="Karl Schultz @karl-lunarg" specialuse="debugging" supported="vulkan">
- <require>
- <enum value="5" name="VK_EXT_VALIDATION_FEATURES_SPEC_VERSION"/>
- <enum value=""VK_EXT_validation_features"" name="VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"/>
- <type name="VkValidationFeaturesEXT"/>
- <type name="VkValidationFeatureEnableEXT"/>
- <type name="VkValidationFeatureDisableEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_present_wait" number="249" type="device" requires="VK_KHR_swapchain,VK_KHR_present_id" author="KHR" contact="Keith Packard @keithp" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_PRESENT_WAIT_SPEC_VERSION"/>
- <enum value=""VK_KHR_present_wait"" name="VK_KHR_PRESENT_WAIT_EXTENSION_NAME"/>
- <command name="vkWaitForPresentKHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"/>
- <type name="VkPhysicalDevicePresentWaitFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_NV_cooperative_matrix" number="250" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION"/>
- <enum value=""VK_NV_cooperative_matrix"" name="VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"/>
- <type name="VkCooperativeMatrixPropertiesNV"/>
- <type name="VkScopeNV"/>
- <type name="VkComponentTypeNV"/>
- <type name="VkPhysicalDeviceCooperativeMatrixFeaturesNV"/>
- <type name="VkPhysicalDeviceCooperativeMatrixPropertiesNV"/>
- <command name="vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"/>
- </require>
- </extension>
- <extension name="VK_NV_coverage_reduction_mode" number="251" requires="VK_NV_framebuffer_mixed_samples" type="device" author="NV" contact="Kedarnath Thangudu @kthangudu" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION"/>
- <enum value=""VK_NV_coverage_reduction_mode"" name="VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"/>
- <type name="VkPhysicalDeviceCoverageReductionModeFeaturesNV"/>
- <type name="VkPipelineCoverageReductionStateCreateInfoNV"/>
- <type name="VkPipelineCoverageReductionStateCreateFlagsNV"/>
- <type name="VkCoverageReductionModeNV"/>
- <type name="VkFramebufferMixedSamplesCombinationNV"/>
- <command name="vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"/>
- </require>
- </extension>
- <extension name="VK_EXT_fragment_shader_interlock" number="252" author="EXT" type="device" requires="VK_KHR_get_physical_device_properties2" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION"/>
- <enum value=""VK_EXT_fragment_shader_interlock"" name="VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_ycbcr_image_arrays" number="253" type="device" requires="VK_KHR_sampler_ycbcr_conversion" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION"/>
- <enum value=""VK_EXT_ycbcr_image_arrays"" name="VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceYcbcrImageArraysFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_uniform_buffer_standard_layout" number="254" requires="VK_KHR_get_physical_device_properties2" type="device" author="KHR" contact="Graeme Leese @gnl21" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION"/>
- <enum value=""VK_KHR_uniform_buffer_standard_layout"" name="VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME"/>
- <type name="VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"/>
- </require>
- </extension>
- <extension name="VK_EXT_provoking_vertex" number="255" type="device" author="EXT" requires="VK_KHR_get_physical_device_properties2" contact="Jesse Hall @jessehall" specialuse="glemulation" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_PROVOKING_VERTEX_SPEC_VERSION"/>
- <enum value=""VK_EXT_provoking_vertex"" name="VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"/>
- <type name="VkPhysicalDeviceProvokingVertexFeaturesEXT"/>
- <type name="VkPhysicalDeviceProvokingVertexPropertiesEXT"/>
- <type name="VkPipelineRasterizationProvokingVertexStateCreateInfoEXT"/>
- <type name="VkProvokingVertexModeEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_full_screen_exclusive" number="256" type="device" author="EXT" requires="VK_KHR_get_physical_device_properties2,VK_KHR_surface,VK_KHR_get_surface_capabilities2,VK_KHR_swapchain" platform="win32" contact="James Jones @cubanismo" supported="vulkan">
- <require>
- <enum value="4" name="VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION"/>
- <enum value=""VK_EXT_full_screen_exclusive"" name="VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"/>
- <enum offset="0" extends="VkResult" dir="-" name="VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"/>
- <type name="VkFullScreenExclusiveEXT"/>
- <type name="VkSurfaceFullScreenExclusiveInfoEXT"/>
- <type name="VkSurfaceCapabilitiesFullScreenExclusiveEXT"/>
- <command name="vkGetPhysicalDeviceSurfacePresentModes2EXT"/>
- <command name="vkAcquireFullScreenExclusiveModeEXT"/>
- <command name="vkReleaseFullScreenExclusiveModeEXT"/>
- </require>
- <require extension="VK_KHR_win32_surface">
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"/>
- <type name="VkSurfaceFullScreenExclusiveWin32InfoEXT"/>
- </require>
- <require extension="VK_KHR_device_group">
- <command name="vkGetDeviceGroupSurfacePresentModes2EXT"/>
- </require>
- <require feature="VK_VERSION_1_1">
- <command name="vkGetDeviceGroupSurfacePresentModes2EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_headless_surface" number="257" type="instance" requires="VK_KHR_surface" author="EXT" contact="Lisa Wu @chengtianww" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_HEADLESS_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_EXT_headless_surface"" name="VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"/>
- <type name="VkHeadlessSurfaceCreateFlagsEXT"/>
- <type name="VkHeadlessSurfaceCreateInfoEXT"/>
- <command name="vkCreateHeadlessSurfaceEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_buffer_device_address" number="258" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION"/>
- <enum value=""VK_KHR_buffer_device_address"" name="VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR" alias="VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR" alias="VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"/>
- <enum extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR" alias="VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"/>
- <enum extends="VkBufferCreateFlagBits" name="VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR" alias="VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"/>
- <enum extends="VkMemoryAllocateFlagBits" name="VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR" alias="VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"/>
- <enum extends="VkMemoryAllocateFlagBits" name="VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR" alias="VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"/>
- <enum extends="VkResult" name="VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR" alias="VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"/>
- <type name="VkPhysicalDeviceBufferDeviceAddressFeaturesKHR"/>
- <type name="VkBufferDeviceAddressInfoKHR"/>
- <type name="VkBufferOpaqueCaptureAddressCreateInfoKHR"/>
- <type name="VkMemoryOpaqueCaptureAddressAllocateInfoKHR"/>
- <type name="VkDeviceMemoryOpaqueCaptureAddressInfoKHR"/>
- <command name="vkGetBufferDeviceAddressKHR"/>
- <command name="vkGetBufferOpaqueCaptureAddressKHR"/>
- <command name="vkGetDeviceMemoryOpaqueCaptureAddressKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_259" number="259" author="EXT" contact="Jeff Leger @jackohound" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_259_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_259"" name="VK_EXT_EXTENSION_259_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_line_rasterization" number="260" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" specialuse="cadsupport" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_LINE_RASTERIZATION_SPEC_VERSION"/>
- <enum value=""VK_EXT_line_rasterization"" name="VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_LINE_STIPPLE_EXT"/>
- <type name="VkPhysicalDeviceLineRasterizationFeaturesEXT"/>
- <type name="VkPhysicalDeviceLineRasterizationPropertiesEXT"/>
- <type name="VkPipelineRasterizationLineStateCreateInfoEXT"/>
- <type name="VkLineRasterizationModeEXT"/>
- <command name="vkCmdSetLineStippleEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_atomic_float" number="261" type="device" author="NV" requires="VK_KHR_get_physical_device_properties2" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_atomic_float"" name="VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_host_query_reset" number="262" author="EXT" contact="Bas Nieuwenhuizen @BNieuwenhuizen" supported="vulkan" type="device" requires="VK_KHR_get_physical_device_properties2" promotedto="VK_VERSION_1_2">
- <require>
- <enum value="1" name="VK_EXT_HOST_QUERY_RESET_SPEC_VERSION"/>
- <enum value=""VK_EXT_host_query_reset"" name="VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME"/>
- <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"/>
- <type name="VkPhysicalDeviceHostQueryResetFeaturesEXT"/>
- <command name="vkResetQueryPoolEXT"/>
- </require>
- </extension>
- <extension name="VK_GGP_extension_263" number="263" author="GGP" contact="Jean-Francois Roy @jfroy" supported="disabled">
- <require>
- <enum value="0" name="VK_GGP_EXTENSION_263_SPEC_VERSION"/>
- <enum value=""VK_GGP_extension_263"" name="VK_GGP_EXTENSION_263_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_BRCM_extension_264" number="264" author="BRCM" contact="Graeme Leese @gnl21" supported="disabled">
- <require>
- <enum value="0" name="VK_BRCM_EXTENSION_264_SPEC_VERSION"/>
- <enum value=""VK_BRCM_extension_264"" name="VK_BRCM_EXTENSION_264_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_BRCM_extension_265" number="265" author="BRCM" contact="Graeme Leese @gnl21" supported="disabled">
- <require>
- <enum value="0" name="VK_BRCM_EXTENSION_265_SPEC_VERSION"/>
- <enum value=""VK_BRCM_extension_265"" name="VK_BRCM_EXTENSION_265_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_index_type_uint8" number="266" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION"/>
- <enum value=""VK_EXT_index_type_uint8"" name="VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"/>
- <enum offset="0" extends="VkIndexType" name="VK_INDEX_TYPE_UINT8_EXT"/>
- <type name="VkPhysicalDeviceIndexTypeUint8FeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_267" number="267" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_267_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_267"" name="VK_EXT_EXTENSION_267_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extended_dynamic_state" number="268" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION"/>
- <enum value=""VK_EXT_extended_dynamic_state"" name="VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_CULL_MODE_EXT"/>
- <enum offset="1" extends="VkDynamicState" name="VK_DYNAMIC_STATE_FRONT_FACE_EXT"/>
- <enum offset="2" extends="VkDynamicState" name="VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT"/>
- <enum offset="3" extends="VkDynamicState" name="VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT"/>
- <enum offset="4" extends="VkDynamicState" name="VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT"/>
- <enum offset="5" extends="VkDynamicState" name="VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT"/>
- <enum offset="6" extends="VkDynamicState" name="VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT"/>
- <enum offset="7" extends="VkDynamicState" name="VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT"/>
- <enum offset="8" extends="VkDynamicState" name="VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT"/>
- <enum offset="9" extends="VkDynamicState" name="VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT"/>
- <enum offset="10" extends="VkDynamicState" name="VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT"/>
- <enum offset="11" extends="VkDynamicState" name="VK_DYNAMIC_STATE_STENCIL_OP_EXT"/>
- <type name="VkPhysicalDeviceExtendedDynamicStateFeaturesEXT"/>
- <command name="vkCmdSetCullModeEXT"/>
- <command name="vkCmdSetFrontFaceEXT"/>
- <command name="vkCmdSetPrimitiveTopologyEXT"/>
- <command name="vkCmdSetViewportWithCountEXT"/>
- <command name="vkCmdSetScissorWithCountEXT"/>
- <command name="vkCmdBindVertexBuffers2EXT"/>
- <command name="vkCmdSetDepthTestEnableEXT"/>
- <command name="vkCmdSetDepthWriteEnableEXT"/>
- <command name="vkCmdSetDepthCompareOpEXT"/>
- <command name="vkCmdSetDepthBoundsTestEnableEXT"/>
- <command name="vkCmdSetStencilTestEnableEXT"/>
- <command name="vkCmdSetStencilOpEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_deferred_host_operations" number="269" type="device" author="KHR" contact="Josh Barczak @jbarczak" supported="vulkan">
- <require>
- <enum value="4" name="VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION"/>
- <enum value=""VK_KHR_deferred_host_operations"" name="VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"/>
- <type name="VkDeferredOperationKHR"/>
- <command name="vkCreateDeferredOperationKHR"/>
- <command name="vkDestroyDeferredOperationKHR"/>
- <command name="vkGetDeferredOperationMaxConcurrencyKHR"/>
- <command name="vkGetDeferredOperationResultKHR"/>
- <command name="vkDeferredOperationJoinKHR" />
- <enum extends="VkResult" offset="0" name="VK_THREAD_IDLE_KHR" />
- <enum extends="VkResult" offset="1" name="VK_THREAD_DONE_KHR" />
- <enum extends="VkResult" offset="2" name="VK_OPERATION_DEFERRED_KHR" />
- <enum extends="VkResult" offset="3" name="VK_OPERATION_NOT_DEFERRED_KHR" />
- </require>
- </extension>
- <extension name="VK_KHR_pipeline_executable_properties" number="270" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Jason Ekstrand @jekstrand" specialuse="devtools" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION"/>
- <enum value=""VK_KHR_pipeline_executable_properties"" name="VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"/>
- <enum bitpos="6" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"/>
- <enum bitpos="7" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"/>
- <type name="VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR"/>
- <type name="VkPipelineInfoKHR"/>
- <type name="VkPipelineExecutablePropertiesKHR"/>
- <type name="VkPipelineExecutableInfoKHR"/>
- <type name="VkPipelineExecutableStatisticFormatKHR"/>
- <type name="VkPipelineExecutableStatisticValueKHR"/>
- <type name="VkPipelineExecutableStatisticKHR"/>
- <type name="VkPipelineExecutableInternalRepresentationKHR"/>
- <command name="vkGetPipelineExecutablePropertiesKHR"/>
- <command name="vkGetPipelineExecutableStatisticsKHR"/>
- <command name="vkGetPipelineExecutableInternalRepresentationsKHR"/>
- </require>
- </extension>
- <extension name="VK_INTEL_extension_271" number="271" type="device" author="INTEL" contact="Jason Ekstrand @jekstrand" supported="disabled">
- <require>
- <enum value="0" name="VK_INTEL_EXTENSION_271_SPEC_VERSION"/>
- <enum value=""VK_INTEL_extension_271"" name="VK_INTEL_EXTENSION_271_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_INTEL_extension_272" number="272" type="device" author="INTEL" contact="Jason Ekstrand @jekstrand" supported="disabled">
- <require>
- <enum value="0" name="VK_INTEL_EXTENSION_272_SPEC_VERSION"/>
- <enum value=""VK_INTEL_extension_272"" name="VK_INTEL_EXTENSION_272_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_INTEL_extension_273" number="273" type="device" author="INTEL" contact="Jason Ekstrand @jekstrand" supported="disabled">
- <require>
- <enum value="0" name="VK_INTEL_EXTENSION_273_SPEC_VERSION"/>
- <enum value=""VK_INTEL_extension_273"" name="VK_INTEL_EXTENSION_273_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_atomic_float2" number="274" type="device" requires="VK_EXT_shader_atomic_float" author="EXT" contact="Jason Ekstrand @jekstrand" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_atomic_float2"" name="VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_275" number="275" type="instance" author="KHR" contact="Lionel Landwerlin @llandwerlin" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_275_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_275"" name="VK_KHR_EXTENSION_275_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_276" number="276" type="device" author="KHR" contact="James Jones @cubanismo" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_276_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_276"" name="VK_KHR_EXTENSION_276_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_shader_demote_to_helper_invocation" number="277" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION"/>
- <enum value=""VK_EXT_shader_demote_to_helper_invocation"" name="VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_NV_device_generated_commands" number="278" type="device" requiresCore="1.1" requires="VK_KHR_buffer_device_address" author="NV" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
- <require>
- <comment>
- This extension requires buffer_device_address functionality.
- VK_EXT_buffer_device_address is also acceptable, but since it is deprecated the KHR version is preferred.
- </comment>
- <enum value="3" name="VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION"/>
- <enum value=""VK_NV_device_generated_commands"" name="VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"/>
- <enum bitpos="18" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV"/>
- <enum bitpos="17" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV"/>
- <enum bitpos="17" extends="VkAccessFlagBits" name="VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV"/>
- <enum bitpos="18" extends="VkAccessFlagBits" name="VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"/>
- <type name="VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV"/>
- <type name="VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV"/>
- <type name="VkGraphicsShaderGroupCreateInfoNV"/>
- <type name="VkGraphicsPipelineShaderGroupsCreateInfoNV"/>
- <type name="VkBindShaderGroupIndirectCommandNV"/>
- <type name="VkBindIndexBufferIndirectCommandNV"/>
- <type name="VkBindVertexBufferIndirectCommandNV"/>
- <type name="VkSetStateFlagsIndirectCommandNV"/>
- <type name="VkIndirectStateFlagBitsNV"/>
- <type name="VkIndirectStateFlagsNV"/>
- <type name="VkIndirectCommandsLayoutNV"/>
- <type name="VkIndirectCommandsTokenTypeNV"/>
- <type name="VkIndirectCommandsLayoutUsageFlagBitsNV"/>
- <type name="VkIndirectCommandsLayoutUsageFlagsNV"/>
- <type name="VkIndirectCommandsStreamNV"/>
- <type name="VkIndirectCommandsLayoutTokenNV"/>
- <type name="VkIndirectCommandsLayoutCreateInfoNV"/>
- <type name="VkGeneratedCommandsInfoNV"/>
- <type name="VkGeneratedCommandsMemoryRequirementsInfoNV"/>
- <command name="vkGetGeneratedCommandsMemoryRequirementsNV"/>
- <command name="vkCmdPreprocessGeneratedCommandsNV"/>
- <command name="vkCmdExecuteGeneratedCommandsNV"/>
- <command name="vkCmdBindPipelineShaderGroupNV"/>
- <command name="vkCreateIndirectCommandsLayoutNV"/>
- <command name="vkDestroyIndirectCommandsLayoutNV"/>
- </require>
- </extension>
- <extension name="VK_NV_inherited_viewport_scissor" number="279" type="device" author="NV" contact="David Zhao Akeley @akeley98" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION"/>
- <enum value=""VK_NV_inherited_viewport_scissor"" name="VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"/>
- <type name="VkPhysicalDeviceInheritedViewportScissorFeaturesNV"/>
- <type name="VkCommandBufferInheritanceViewportScissorInfoNV"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_280" number="280" type="device" author="KHR" contact="Kevin Petit @kevinpetit" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_280_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_280"" name="VK_KHR_EXTENSION_280_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_integer_dot_product" number="281" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Kevin Petit @kevinpetit" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_integer_dot_product"" name="VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR"/>
- <type name="VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR"/>
- <type name="VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_texel_buffer_alignment" number="282" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION"/>
- <enum value=""VK_EXT_texel_buffer_alignment"" name="VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"/>
- <type name="VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT"/>
- <type name="VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_QCOM_render_pass_transform" number="283" type="device" requires="VK_KHR_swapchain,VK_KHR_surface" author="QCOM" contact="Jeff Leger @jackohound" supported="vulkan">
- <require>
- <enum value="2" name="VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION"/>
- <enum value=""VK_QCOM_render_pass_transform"" name="VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"/>
- <enum bitpos="1" extends="VkRenderPassCreateFlagBits" name="VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM"/>
- <type name="VkRenderPassTransformBeginInfoQCOM"/>
- <type name="VkCommandBufferInheritanceRenderPassTransformInfoQCOM"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_284" number="284" type="device" author="EXT" contact="Samuel Pitoiset @hakzsam" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_284_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_284"" name="VK_EXT_EXTENSION_284_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_device_memory_report" number="285" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Yiwei Zhang @zhangyiwei" specialuse="devtools" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION"/>
- <enum value=""VK_EXT_device_memory_report"" name="VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"/>
- <type name="VkPhysicalDeviceDeviceMemoryReportFeaturesEXT"/>
- <type name="VkDeviceDeviceMemoryReportCreateInfoEXT"/>
- <type name="VkDeviceMemoryReportCallbackDataEXT"/>
- <type name="VkDeviceMemoryReportFlagsEXT"/>
- <type name="VkDeviceMemoryReportEventTypeEXT"/>
- <type name="PFN_vkDeviceMemoryReportCallbackEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_acquire_drm_display" number="286" type="instance" requires="VK_EXT_direct_mode_display" author="EXT" contact="Drew DeVault [email protected]" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION"/>
- <enum value=""VK_EXT_acquire_drm_display"" name="VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME"/>
- <command name="vkAcquireDrmDisplayEXT"/>
- <command name="vkGetDrmDisplayEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_robustness2" number="287" type="device" author="EXT" contact="Liam Middlebrook @liam-middlebrook" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_ROBUSTNESS_2_SPEC_VERSION"/>
- <enum value=""VK_EXT_robustness2"" name="VK_EXT_ROBUSTNESS_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"/>
- <type name="VkPhysicalDeviceRobustness2FeaturesEXT"/>
- <type name="VkPhysicalDeviceRobustness2PropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_custom_border_color" number="288" type="device" author="EXT" contact="Liam Middlebrook @liam-middlebrook" specialuse="glemulation,d3demulation" supported="vulkan">
- <require>
- <enum value="12" name="VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION"/>
- <enum value=""VK_EXT_custom_border_color"" name="VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"/>
- <enum offset="3" extends="VkBorderColor" name="VK_BORDER_COLOR_FLOAT_CUSTOM_EXT"/>
- <enum offset="4" extends="VkBorderColor" name="VK_BORDER_COLOR_INT_CUSTOM_EXT"/>
- <type name="VkSamplerCustomBorderColorCreateInfoEXT"/>
- <type name="VkPhysicalDeviceCustomBorderColorPropertiesEXT"/>
- <type name="VkPhysicalDeviceCustomBorderColorFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_289" number="289" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <comment>
- These enums are present only to inform downstream
- consumers like KTX2. There is no actual Vulkan extension
- corresponding to the enums.
- </comment>
- <enum value="0" name="VK_EXT_EXTENSION_289_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_289"" name="VK_EXT_EXTENSION_289_EXTENSION_NAME"/>
- <enum extends="VkFormat" extnumber="289" offset="0" name="VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="1" name="VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="2" name="VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="3" name="VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="4" name="VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="5" name="VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="6" name="VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="7" name="VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="8" name="VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="9" name="VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="10" name="VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="11" name="VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="12" name="VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="13" name="VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="14" name="VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="15" name="VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="16" name="VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="17" name="VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="18" name="VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="19" name="VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="20" name="VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="21" name="VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="22" name="VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="23" name="VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="24" name="VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="25" name="VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="26" name="VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="27" name="VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="28" name="VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT"/>
- <enum extends="VkFormat" extnumber="289" offset="29" name="VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_user_type" number="290" type="device" author="GOOGLE" contact="Kaye Mason @chaleur" supported="vulkan">
- <require>
- <enum value="1" name="VK_GOOGLE_USER_TYPE_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_user_type"" name="VK_GOOGLE_USER_TYPE_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_pipeline_library" number="291" type="device" author="KHR" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION"/>
- <enum value=""VK_KHR_pipeline_library"" name="VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME"/>
- <enum bitpos="11" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_LIBRARY_BIT_KHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR"/>
- <type name="VkPipelineLibraryCreateInfoKHR"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_292" number="292" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_292_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_292"" name="VK_NV_EXTENSION_292_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_293" number="293" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_293_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_293"" name="VK_NV_EXTENSION_293_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_non_semantic_info" number="294" type="device" author="KHR" contact="Baldur Karlsson @baldurk" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_non_semantic_info"" name="VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_present_id" number="295" type="device" requires="VK_KHR_swapchain" author="KHR" contact="Keith Packard @keithp" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_PRESENT_ID_SPEC_VERSION"/>
- <enum value=""VK_KHR_present_id"" name="VK_KHR_PRESENT_ID_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PRESENT_ID_KHR"/>
- <type name="VkPresentIdKHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"/>
- <type name="VkPhysicalDevicePresentIdFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_private_data" number="296" type="device" author="NV" contact="Matthew Rusch @mattruschnv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_PRIVATE_DATA_SPEC_VERSION"/>
- <enum value=""VK_EXT_private_data"" name="VK_EXT_PRIVATE_DATA_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT"/>
- <type name="VkPhysicalDevicePrivateDataFeaturesEXT"/>
- <type name="VkDevicePrivateDataCreateInfoEXT"/>
- <type name="VkPrivateDataSlotCreateInfoEXT"/>
- <type name="VkPrivateDataSlotEXT"/>
- <type name="VkPrivateDataSlotCreateFlagsEXT"/>
- <type name="VkPrivateDataSlotCreateFlagBitsEXT"/>
- <command name="vkCreatePrivateDataSlotEXT"/>
- <command name="vkDestroyPrivateDataSlotEXT"/>
- <command name="vkSetPrivateDataEXT"/>
- <command name="vkGetPrivateDataEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_297" number="297" author="KHR" contact="Corentin Wallez @Kangz" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_297_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_297"" name="VK_KHR_EXTENSION_297_EXTENSION_NAME"/>
- <enum bitpos="3" extends="VkPipelineShaderStageCreateFlagBits" name="VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_pipeline_creation_cache_control" number="298" type="device" author="AMD" contact="Gregory Grebe @grgrebe_amd" supported="vulkan">
- <require>
- <enum value="3" name="VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION"/>
- <enum value=""VK_EXT_pipeline_creation_cache_control""
- name="VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType"
- name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT"/>
- <type name="VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT"/>
- <enum bitpos="8" extends="VkPipelineCreateFlagBits"
- name="VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT"/>
- <enum bitpos="9" extends="VkPipelineCreateFlagBits"
- name="VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT"/>
- <enum extends="VkResult" offset="0" name="VK_PIPELINE_COMPILE_REQUIRED_EXT"/>
- <enum extends="VkResult" name="VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT" alias="VK_PIPELINE_COMPILE_REQUIRED_EXT"/>
- <enum bitpos="0" extends="VkPipelineCacheCreateFlagBits"
- name="VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT"/>
- <type name="VkPipelineCacheCreateFlagBits" comment="This is a temporary workaround for processors not recognizing that VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT above also requires this type"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_299" number="299" author="KHR" contact="Mark Bellamy @mark.bellamy_arm" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_299_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_299"" name="VK_KHR_EXTENSION_299_EXTENSION_NAME"/>
- <enum bitpos="2" extends="VkMemoryHeapFlagBits" name="VK_MEMORY_HEAP_RESERVED_2_BIT_KHR"/>
- <enum extends="VkPipelineCacheCreateFlagBits" name="VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_KHR" alias="VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT"/>
- <enum bitpos="2" extends="VkPipelineCacheCreateFlagBits" name="VK_PIPELINE_CACHE_CREATE_RESERVED_2_BIT_KHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_video_encode_queue" number="300" type="device" requires="VK_KHR_video_queue,VK_KHR_synchronization2" author="KHR" contact="[email protected]" provisional="true" platform="provisional" supported="vulkan">
- <require>
- <enum value="3" name="VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION"/>
- <enum value=""VK_KHR_video_encode_queue"" name="VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME"/>
- <enum bitpos="27" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS" />
- <enum bitpos="37" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS" />
- <enum bitpos="38" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="6" extends="VkQueueFlagBits" name="VK_QUEUE_VIDEO_ENCODE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="15" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="16" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="13" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="14" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="15" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="27" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="28" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="0" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="1" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="2" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum offset="0" extends="VkQueryType" name="VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
-
- <type name="VkVideoEncodeFlagBitsKHR"/>
- <type name="VkVideoEncodeFlagsKHR"/>
- <type name="VkVideoEncodeInfoKHR"/>
-
- <type name="VkVideoEncodeRateControlFlagBitsKHR"/>
- <type name="VkVideoEncodeRateControlFlagsKHR"/>
- <type name="VkVideoEncodeRateControlModeFlagBitsKHR"/>
- <type name="VkVideoEncodeRateControlModeFlagsKHR"/>
-
- <type name="VkVideoEncodeRateControlInfoKHR"/>
- <command name="vkCmdEncodeVideoKHR"/>
- </require>
- <require extension="VK_KHR_format_feature_flags2">
- <enum bitpos="27" extends="VkFormatFeatureFlagBits2KHR" name="VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <enum bitpos="28" extends="VkFormatFeatureFlagBits2KHR" name="VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- </require>
- </extension>
- <extension name="VK_NV_device_diagnostics_config" number="301" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Kedarnath Thangudu @kthangudu" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION"/>
- <enum value=""VK_NV_device_diagnostics_config"" name="VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"/>
- <type name="VkPhysicalDeviceDiagnosticsConfigFeaturesNV"/>
- <type name="VkDeviceDiagnosticsConfigCreateInfoNV"/>
- <type name="VkDeviceDiagnosticsConfigFlagsNV"/>
- <type name="VkDeviceDiagnosticsConfigFlagBitsNV"/>
- </require>
- </extension>
- <extension name="VK_QCOM_render_pass_store_ops" number="302" type="device" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="vulkan">
- <require>
- <enum value="2" name="VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION"/>
- <enum value=""VK_QCOM_render_pass_store_ops"" name="VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME"/>
- <enum extends="VkAttachmentStoreOp" name="VK_ATTACHMENT_STORE_OP_NONE_QCOM" alias="VK_ATTACHMENT_STORE_OP_NONE_KHR"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_303" number="303" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_303_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_303"" name="VK_QCOM_EXTENSION_303_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_304" number="304" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_304_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_304"" name="VK_QCOM_EXTENSION_304_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_305" number="305" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_305_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_305"" name="VK_QCOM_EXTENSION_305_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_306" number="306" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_306_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_306"" name="VK_QCOM_EXTENSION_306_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_307" number="307" author="QCOM" contact="Bill Licea-Kane @wwlk" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_307_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_307"" name="VK_QCOM_EXTENSION_307_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_308" number="308" type="device" author="NV" contact="Tristan Lorach @tlorach" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_308_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_308"" name="VK_NV_EXTENSION_308_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_309" number="309" author="KHR" contact="Aidan Fabius @afabius" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_309_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_309"" name="VK_KHR_EXTENSION_309_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_310" number="310" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_310_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_310"" name="VK_QCOM_EXTENSION_310_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RESERVED_QCOM"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_311" number="311" author="NV" contact="Charles Hansen @cshansen" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_311_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_311"" name="VK_NV_EXTENSION_311_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_312" number="312" author="MVK" contact="Bill Hollings @billhollings" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_312_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_312"" name="VK_EXT_EXTENSION_312_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_313" number="313" author="MVK" contact="Bill Hollings @billhollings" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_313_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_313"" name="VK_EXT_EXTENSION_313_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_314" number="314" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_314_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_314"" name="VK_AMD_EXTENSION_314_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_synchronization2" number="315" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Tobias Hector @tobski" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_synchronization2"" name="VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR"/>
- <enum bitpos="0" extends="VkEventCreateFlagBits" name="VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR"/>
- <enum offset="0" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR"/>
- <enum offset="1" extends="VkImageLayout" name="VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR"/>
- <enum value="0" extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_NONE_KHR"/>
- <enum value="0" extends="VkAccessFlagBits" name="VK_ACCESS_NONE_KHR"/>
- <type name="VkFlags64"/>
- <type name="VkPipelineStageFlags2KHR"/>
- <type name="VkPipelineStageFlagBits2KHR"/>
- <type name="VkAccessFlags2KHR"/>
- <type name="VkAccessFlagBits2KHR"/>
- <type name="VkMemoryBarrier2KHR"/>
- <type name="VkBufferMemoryBarrier2KHR"/>
- <type name="VkImageMemoryBarrier2KHR"/>
- <type name="VkDependencyInfoKHR"/>
- <type name="VkSubmitInfo2KHR"/>
- <type name="VkSemaphoreSubmitInfoKHR"/>
- <type name="VkCommandBufferSubmitInfoKHR"/>
- <type name="VkSubmitFlagBitsKHR"/>
- <type name="VkSubmitFlagsKHR"/>
- <type name="VkPhysicalDeviceSynchronization2FeaturesKHR"/>
- <command name="vkCmdSetEvent2KHR"/>
- <command name="vkCmdResetEvent2KHR"/>
- <command name="vkCmdWaitEvents2KHR"/>
- <command name="vkCmdPipelineBarrier2KHR"/>
- <command name="vkCmdWriteTimestamp2KHR"/>
- <command name="vkQueueSubmit2KHR"/>
- </require>
- <require extension="VK_EXT_transform_feedback">
- <enum bitpos="24" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT"/>
- <enum bitpos="25" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"/>
- <enum bitpos="26" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"/>
- <enum bitpos="27" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"/>
- </require>
- <require extension="VK_EXT_conditional_rendering">
- <enum bitpos="18" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" comment="A pipeline stage for conditional rendering predicate fetch"/>
- <enum bitpos="20" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT" comment="read access flag for reading conditional rendering predicate"/>
- </require>
- <require extension="VK_NV_device_generated_commands">
- <enum bitpos="17" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV"/>
- <enum bitpos="17" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV"/>
- <enum bitpos="18" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV"/>
- </require>
- <require extension="VK_KHR_fragment_shading_rate">
- <enum bitpos="22" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- <enum bitpos="23" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"/>
- </require>
- <require extension="VK_NV_shading_rate_image">
- <enum extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" alias="VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
- <enum extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV" alias="VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"/>
- </require>
- <require extension="VK_KHR_acceleration_structure">
- <enum bitpos="25" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"/>
- <enum bitpos="21" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"/>
- <enum bitpos="22" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"/>
- </require>
- <require extension="VK_KHR_ray_tracing_pipeline">
- <enum bitpos="21" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"/>
- </require>
- <require extension="VK_NV_ray_tracing">
- <enum extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV" alias="VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"/>
- <enum extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV" alias="VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"/>
- <enum extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV" alias="VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"/>
- <enum extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV" alias="VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"/>
- </require>
- <require extension="VK_EXT_fragment_density_map">
- <enum bitpos="23" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT"/>
- <enum bitpos="24" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"/>
- </require>
- <require extension="VK_EXT_blend_operation_advanced">
- <enum bitpos="19" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"/>
- </require>
- <require extension="VK_NV_mesh_shader">
- <enum bitpos="19" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV"/>
- <enum bitpos="20" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV"/>
- </require>
- <require extension="VK_AMD_buffer_marker">
- <command name="vkCmdWriteBufferMarker2AMD"/>
- </require>
- <require extension="VK_NV_device_diagnostic_checkpoints">
- <type name="VkQueueFamilyCheckpointProperties2NV"/>
- <type name="VkCheckpointData2NV"/>
- <command name="vkGetQueueCheckpointData2NV"/>
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_316" number="316" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_316_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_316"" name="VK_AMD_EXTENSION_316_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_317" number="317" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_317_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_317"" name="VK_AMD_EXTENSION_317_EXTENSION_NAME"/>
- <enum bitpos="4" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_4_BIT_AMD"/>
- <enum bitpos="21" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_21_BIT_AMD"/>
- <enum bitpos="22" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_22_BIT_AMD"/>
- <enum bitpos="5" extends="VkBufferCreateFlagBits" name="VK_BUFFER_CREATE_RESERVED_5_BIT_AMD"/>
- <enum bitpos="16" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_RESERVED_16_BIT_AMD"/>
- <enum bitpos="3" extends="VkSamplerCreateFlagBits" name="VK_SAMPLER_CREATE_RESERVED_3_BIT_AMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_318" number="318" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_318_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_318"" name="VK_AMD_EXTENSION_318_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_319" number="319" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_319_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_319"" name="VK_AMD_EXTENSION_319_EXTENSION_NAME"/>
- <enum bitpos="3" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD"/>
- <enum bitpos="0" extends="VkPipelineLayoutCreateFlagBits" name="VK_PIPELINE_LAYOUT_CREATE_RESERVED_0_BIT_AMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_320" number="320" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_320_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_320"" name="VK_AMD_EXTENSION_320_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_321" number="321" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_321_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_321"" name="VK_AMD_EXTENSION_321_EXTENSION_NAME"/>
- <enum bitpos="23" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RESERVED_23_BIT_AMD"/>
- <enum bitpos="10" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RESERVED_10_BIT_AMD"/>
- <enum bitpos="1" extends="VkPipelineLayoutCreateFlagBits" name="VK_PIPELINE_LAYOUT_CREATE_RESERVED_1_BIT_AMD"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_322" number="322" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_322_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_322"" name="VK_AMD_EXTENSION_322_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_AMD_extension_323" number="323" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
- <require>
- <enum value="0" name="VK_AMD_EXTENSION_323_SPEC_VERSION"/>
- <enum value=""VK_AMD_extension_323"" name="VK_AMD_EXTENSION_323_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_shader_subgroup_uniform_control_flow" number="324" type="device" requiresCore="1.1" author="KHR" contact="Alan Baker @alan-baker" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION"/>
- <enum value=""VK_KHR_shader_subgroup_uniform_control_flow"" name="VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"/>
- <type name="VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_325" number="325" author="KHR" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_325_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_325"" name="VK_KHR_EXTENSION_325_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_zero_initialize_workgroup_memory" number="326" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Alan Baker @alan-baker" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION"/>
- <enum value=""VK_KHR_zero_initialize_workgroup_memory"" name="VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"/>
- <type name="VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_NV_fragment_shading_rate_enums" number="327" type="device" requires="VK_KHR_fragment_shading_rate" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION"/>
- <enum value=""VK_NV_fragment_shading_rate_enums"" name="VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"/>
- <type name="VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV"/>
- <type name="VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV"/>
- <type name="VkPipelineFragmentShadingRateEnumStateCreateInfoNV"/>
- <type name="VkFragmentShadingRateNV"/>
- <type name="VkFragmentShadingRateTypeNV"/>
- <command name="vkCmdSetFragmentShadingRateEnumNV"/>
- </require>
- </extension>
- <extension name="VK_NV_ray_tracing_motion_blur" number="328" type="device" requires="VK_KHR_ray_tracing_pipeline" author="NV" contact="Eric Werness" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION"/>
- <enum value=""VK_NV_ray_tracing_motion_blur"" name="VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV"/>
- <enum bitpos="5" extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV"/>
- <enum bitpos="2" extends="VkAccelerationStructureCreateFlagBitsKHR" name="VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV"/>
- <enum bitpos="20" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV"/>
- <type name="VkAccelerationStructureGeometryMotionTrianglesDataNV"/>
- <type name="VkAccelerationStructureMotionInfoNV"/>
- <type name="VkAccelerationStructureMotionInstanceNV"/>
- <type name="VkAccelerationStructureMotionInstanceDataNV"/>
- <type name="VkAccelerationStructureMatrixMotionInstanceNV"/>
- <type name="VkAccelerationStructureSRTMotionInstanceNV"/>
- <type name="VkSRTDataNV"/>
- <type name="VkAccelerationStructureMotionInstanceTypeNV"/>
- <type name="VkPhysicalDeviceRayTracingMotionBlurFeaturesNV"/>
- <type name="VkAccelerationStructureMotionInfoFlagsNV"/>
- <type name="VkAccelerationStructureMotionInstanceFlagsNV"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_329" number="329" author="NV" contact="Pat Brown @nvpbrown" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_329_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_329"" name="VK_NV_EXTENSION_329_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_330" number="330" author="NV" contact="Liam Middlebrook @liam-middlebrook" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_330_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_330"" name="VK_NV_EXTENSION_330_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_ycbcr_2plane_444_formats" number="331" type="device" requires="VK_KHR_sampler_ycbcr_conversion" author="EXT" contact="Tony Zlatinski @tzlatinski" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION"/>
- <enum value=""VK_EXT_ycbcr_2plane_444_formats"" name="VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"/>
- <enum offset="0" extends="VkFormat" name="VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT"/>
- <enum offset="1" extends="VkFormat" name="VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT"/>
- <enum offset="2" extends="VkFormat" name="VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT"/>
- <enum offset="3" extends="VkFormat" name="VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT"/>
- <type name="VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_332" number="332" author="NV" contact="Tony Zlatinski @tzlatinski" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_332_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_332"" name="VK_NV_EXTENSION_332_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_fragment_density_map2" number="333" type="device" requires="VK_EXT_fragment_density_map" author="EXT" contact="Matthew Netsch @mnetsch" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION"/>
- <enum value=""VK_EXT_fragment_density_map2"" name="VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"/>
- <enum bitpos="1" extends="VkImageViewCreateFlagBits" name="VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT"/>
- <type name="VkPhysicalDeviceFragmentDensityMap2FeaturesEXT"/>
- <type name="VkPhysicalDeviceFragmentDensityMap2PropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_QCOM_rotated_copy_commands" number="334" type="device" requires="VK_KHR_swapchain,VK_KHR_copy_commands2" author="QCOM" contact="Jeff Leger @jackohound" supported="vulkan">
- <require>
- <enum value="1" name="VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION"/>
- <enum value=""VK_QCOM_rotated_copy_commands"" name="VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"/>
- <type name="VkCopyCommandTransformInfoQCOM"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_335" number="335" author="KHR" contact="Mark Bellamy @mark.bellamy_arm" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_335_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_335"" name="VK_KHR_EXTENSION_335_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_image_robustness" number="336" type="device" author="EXT" contact="Graeme Leese @gnl21" supported="vulkan" requires="VK_KHR_get_physical_device_properties2">
- <require>
- <enum value="1" name="VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION"/>
- <enum value=""VK_EXT_image_robustness"" name="VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceImageRobustnessFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_workgroup_memory_explicit_layout" number="337" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Caio Marcelo de Oliveira Filho @cmarcelo" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION"/>
- <enum value=""VK_KHR_workgroup_memory_explicit_layout"" name="VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"/>
- <type name="VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"/>
- </require>
- </extension>
- <extension name="VK_KHR_copy_commands2" number="338" author="KHR" type="device" contact="Jeff Leger @jackohound" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_COPY_COMMANDS_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_copy_commands2"" name="VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR"/>
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR"/>
- <enum offset="10" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR"/>
- <type name="VkCopyBufferInfo2KHR"/>
- <type name="VkCopyImageInfo2KHR"/>
- <type name="VkCopyBufferToImageInfo2KHR"/>
- <type name="VkCopyImageToBufferInfo2KHR"/>
- <type name="VkBlitImageInfo2KHR"/>
- <type name="VkResolveImageInfo2KHR"/>
- <type name="VkBufferCopy2KHR"/>
- <type name="VkImageCopy2KHR"/>
- <type name="VkImageBlit2KHR"/>
- <type name="VkBufferImageCopy2KHR"/>
- <type name="VkImageResolve2KHR"/>
- <command name="vkCmdCopyBuffer2KHR"/>
- <command name="vkCmdCopyImage2KHR"/>
- <command name="vkCmdCopyBufferToImage2KHR"/>
- <command name="vkCmdCopyImageToBuffer2KHR"/>
- <command name="vkCmdBlitImage2KHR"/>
- <command name="vkCmdResolveImage2KHR"/>
- </require>
- </extension>
- <extension name="VK_ARM_extension_339" number="339" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <enum value="0" name="VK_ARM_EXTENSION_339_SPEC_VERSION"/>
- <enum value=""VK_ARM_extension_339"" name="VK_ARM_EXTENSION_339_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_340" number="340" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_340_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_340"" name="VK_EXT_EXTENSION_340_EXTENSION_NAME"/>
- <enum bitpos="19" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_19_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_4444_formats" number="341" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_4444_FORMATS_SPEC_VERSION"/>
- <enum value=""VK_EXT_4444_formats"" name="VK_EXT_4444_FORMATS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"/>
- <enum offset="0" extends="VkFormat" name="VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT"/>
- <enum offset="1" extends="VkFormat" name="VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT"/>
- <type name="VkPhysicalDevice4444FormatsFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_342" number="342" author="EXT" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_342_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_342"" name="VK_EXT_EXTENSION_342_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_ARM_extension_343" number="343" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <enum value="0" name="VK_ARM_EXTENSION_343_SPEC_VERSION"/>
- <enum value=""VK_ARM_extension_343"" name="VK_ARM_EXTENSION_343_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_ARM_extension_344" number="344" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <enum value="0" name="VK_ARM_EXTENSION_344_SPEC_VERSION"/>
- <enum value=""VK_ARM_extension_344"" name="VK_ARM_EXTENSION_344_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_rgba10x6_formats" number="345" type="device" requires="VK_KHR_sampler_ycbcr_conversion" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION"/>
- <enum value=""VK_EXT_rgba10x6_formats"" name="VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"/>
- <type name="VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_NV_acquire_winrt_display" number="346" type="device" requires="VK_EXT_direct_mode_display" author="NV" contact="Jeff Juliano @jjuliano" platform="win32" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION"/>
- <enum value=""VK_NV_acquire_winrt_display"" name="VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME"/>
- <command name="vkAcquireWinrtDisplayNV"/>
- <command name="vkGetWinrtDisplayNV"/>
- </require>
- </extension>
- <extension name="VK_EXT_directfb_surface" number="347" type="instance" requires="VK_KHR_surface" platform="directfb" supported="vulkan" author="EXT" contact="Nicolas Caramelli @caramelli">
- <require>
- <enum value="1" name="VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_EXT_directfb_surface"" name="VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT"/>
- <type name="VkDirectFBSurfaceCreateFlagsEXT"/>
- <type name="VkDirectFBSurfaceCreateInfoEXT"/>
- <command name="vkCreateDirectFBSurfaceEXT"/>
- <command name="vkGetPhysicalDeviceDirectFBPresentationSupportEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_350" number="350" author="KHR" contact="Mark Bellamy @mark.bellamy_arm" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_350_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_350"" name="VK_KHR_EXTENSION_350_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_351" number="351" author="NV" contact="Liam Middlebrook @liam-middlebrook" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_351_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_351"" name="VK_NV_EXTENSION_351_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_VALVE_mutable_descriptor_type" number="352" type="device" supported="vulkan" author="VALVE" contact="Joshua Ashton @Joshua-Ashton,Hans-Kristian Arntzen @HansKristian-Work" specialuse="d3demulation" requires="VK_KHR_maintenance3">
- <require>
- <enum value="1" name="VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION"/>
- <enum value=""VK_VALVE_mutable_descriptor_type"" name="VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"/>
- <enum offset="0" extends="VkDescriptorType" name="VK_DESCRIPTOR_TYPE_MUTABLE_VALVE"/>
- <enum bitpos="2" extends="VkDescriptorPoolCreateFlagBits" name="VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE"/>
- <enum bitpos="2" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE"/>
- <type name="VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE"/>
- <type name="VkMutableDescriptorTypeListVALVE"/>
- <type name="VkMutableDescriptorTypeCreateInfoVALVE"/>
- </require>
- </extension>
- <extension name="VK_EXT_vertex_input_dynamic_state" number="353" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="2" name="VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION"/>
- <enum value=""VK_EXT_vertex_input_dynamic_state"" name="VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_VERTEX_INPUT_EXT"/>
- <type name="VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"/>
- <type name="VkVertexInputBindingDescription2EXT"/>
- <type name="VkVertexInputAttributeDescription2EXT"/>
- <command name="vkCmdSetVertexInputEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_physical_device_drm" number="354" author="EXT" type="device" contact="Simon Ser @emersion" supported="vulkan" requires="VK_KHR_get_physical_device_properties2">
- <require>
- <enum value="1" name="VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION"/>
- <enum value=""VK_EXT_physical_device_drm"" name="VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME"/>
-
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"/>
-
- <type name="VkPhysicalDeviceDrmPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_355" number="355" author="EXT" contact="Ralph Potter gitlab:@r_potter" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_355_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_355"" name="VK_EXT_EXTENSION_355_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_vertex_attribute_aliasing" number="356" type="device" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled" specialuse="glemulation">
- <require>
- <enum value="0" name="VK_EXT_VERTEX_ATTRIBUTE_ALIASING_SPEC_VERSION"/>
- <enum value=""VK_EXT_vertex_attribute_aliasing"" name="VK_EXT_VERTEX_ATTRIBUTE_ALIASING_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_primitive_topology_list_restart" number="357" type="device" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" specialuse="glemulation">
- <require>
- <enum value="1" name="VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION"/>
- <enum value=""VK_EXT_primitive_topology_list_restart"" name="VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"/>
- <type name="VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_358" number="358" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_358_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_358"" name="VK_KHR_EXTENSION_358_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_359" number="359" author="EXT" contact="Bill Hollings @billhollings" supported="disabled" specialuse="glemulation">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_359_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_359"" name="VK_EXT_EXTENSION_359_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_360" number="360" author="EXT" contact="Bill Hollings @billhollings" supported="disabled" specialuse="glemulation">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_360_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_360"" name="VK_EXT_EXTENSION_360_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_format_feature_flags2" number="361" author="KHR" type="device" requires="VK_KHR_get_physical_device_properties2" contact="Lionel Landwerlin @llandwerlin" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION"/>
- <enum value=""VK_KHR_format_feature_flags2"" name="VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR"/>
- <type name="VkFormatFeatureFlags2KHR"/>
- <type name="VkFormatFeatureFlagBits2KHR"/>
- <type name="VkFormatProperties3KHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_362" number="362" author="EXT" contact="Lionel Duc @nvlduc" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_362_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_362"" name="VK_EXT_EXTENSION_362_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_363" number="363" author="EXT" contact="Kaye Mason @chaleur" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_363_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_363"" name="VK_EXT_EXTENSION_363_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_FUCHSIA_extension_364" number="364" author="FUCHSIA" contact="Craig Stout @cdotstout" supported="disabled">
- <require>
- <enum value="0" name="VK_FUCHSIA_EXTENSION_364_SPEC_VERSION"/>
- <enum value=""VK_FUCHSIA_extension_364"" name="VK_FUCHSIA_EXTENSION_364_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_FUCHSIA_external_memory" number="365" type="device" requires="VK_KHR_external_memory_capabilities,VK_KHR_external_memory" author="FUCHSIA" contact="John Rosasco @rosasco" platform="fuchsia" supported="vulkan">
- <require>
- <enum value="1" name="VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION"/>
- <enum value=""VK_FUCHSIA_external_memory"" name="VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"/>
- <enum bitpos="11" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"/>
- <type name="VkImportMemoryZirconHandleInfoFUCHSIA"/>
- <type name="VkMemoryZirconHandlePropertiesFUCHSIA"/>
- <type name="VkMemoryGetZirconHandleInfoFUCHSIA"/>
- <command name="vkGetMemoryZirconHandleFUCHSIA"/>
- <command name="vkGetMemoryZirconHandlePropertiesFUCHSIA"/>
- </require>
- </extension>
- <extension name="VK_FUCHSIA_external_semaphore" number="366" type="device" requires="VK_KHR_external_semaphore_capabilities,VK_KHR_external_semaphore" author="FUCHSIA" contact="John Rosasco @rosasco" platform="fuchsia" supported="vulkan">
- <require>
- <enum value="1" name="VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION"/>
- <enum value=""VK_FUCHSIA_external_semaphore"" name="VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"/>
- <enum bitpos="7" extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"/>
- <type name="VkImportSemaphoreZirconHandleInfoFUCHSIA"/>
- <type name="VkSemaphoreGetZirconHandleInfoFUCHSIA"/>
- <command name="vkImportSemaphoreZirconHandleFUCHSIA"/>
- <command name="vkGetSemaphoreZirconHandleFUCHSIA"/>
- </require>
- </extension>
- <extension name="VK_FUCHSIA_buffer_collection" number="367" type="device" requires="VK_FUCHSIA_external_memory,VK_KHR_sampler_ycbcr_conversion" author="FUCHSIA" contact="John Rosasco @rosasco" supported="vulkan" platform="fuchsia">
- <require>
- <enum value="2" name="VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION"/>
- <enum value=""VK_FUCHSIA_buffer_collection"" name="VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"/>
- <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA" comment="VkBufferCollectionFUCHSIA"/>
- <enum offset="0" extends="VkDebugReportObjectTypeEXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"/>
- <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"/>
- <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"/>
- <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"/>
- <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"/>
- <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"/>
- <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"/>
- <type name="VkBufferCollectionFUCHSIA"/>
- <type name="VkBufferCollectionCreateInfoFUCHSIA"/>
- <type name="VkImportMemoryBufferCollectionFUCHSIA"/>
- <type name="VkBufferCollectionImageCreateInfoFUCHSIA"/>
- <type name="VkBufferConstraintsInfoFUCHSIA"/>
- <type name="VkBufferCollectionBufferCreateInfoFUCHSIA"/>
- <type name="VkBufferCollectionPropertiesFUCHSIA"/>
- <type name="VkImageFormatConstraintsFlagsFUCHSIA" comment="Will add VkImageFormatConstraintsFlagBitsFUCHSIA when bits are defined in the future"/>
- <type name="VkSysmemColorSpaceFUCHSIA"/>
- <type name="VkImageConstraintsInfoFlagBitsFUCHSIA"/>
- <type name="VkImageConstraintsInfoFlagsFUCHSIA"/>
- <type name="VkImageConstraintsInfoFUCHSIA"/>
- <type name="VkImageFormatConstraintsInfoFUCHSIA"/>
- <type name="VkBufferCollectionConstraintsInfoFUCHSIA"/>
- <command name="vkCreateBufferCollectionFUCHSIA"/>
- <command name="vkSetBufferCollectionImageConstraintsFUCHSIA"/>
- <command name="vkSetBufferCollectionBufferConstraintsFUCHSIA"/>
- <command name="vkDestroyBufferCollectionFUCHSIA"/>
- <command name="vkGetBufferCollectionPropertiesFUCHSIA"/>
- </require>
- </extension>
- <extension name="VK_FUCHSIA_extension_368" number="368" author="FUCHSIA" contact="Craig Stout @cdotstout" supported="disabled">
- <require>
- <enum value="0" name="VK_FUCHSIA_EXTENSION_368_SPEC_VERSION"/>
- <enum value=""VK_FUCHSIA_extension_368"" name="VK_FUCHSIA_EXTENSION_368_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_369" number="369" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_369_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_369"" name="VK_QCOM_EXTENSION_369_EXTENSION_NAME"/>
- <enum bitpos="4" extends="VkDescriptorBindingFlagBits" name="VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM"/>
- </require>
- </extension>
- <extension name="VK_HUAWEI_subpass_shading" number="370" type="device" author="HUAWEI" contact="Hueilong Wang @wyvernathuawei" requires="VK_KHR_create_renderpass2,VK_KHR_synchronization2" supported="vulkan">
- <require>
- <enum value="2" name="VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION"/>
- <enum value=""VK_HUAWEI_subpass_shading"" name="VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"/>
- <enum offset="3" extends="VkPipelineBindPoint" extnumber="370" name="VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI"/>
- <enum bitpos="39" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI"/>
- <enum bitpos="14" extends="VkShaderStageFlagBits" name="VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI"/>
- <type name="VkSubpassShadingPipelineCreateInfoHUAWEI"/>
- <type name="VkPhysicalDeviceSubpassShadingFeaturesHUAWEI"/>
- <type name="VkPhysicalDeviceSubpassShadingPropertiesHUAWEI"/>
- <command name="vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"/>
- <command name="vkCmdSubpassShadingHUAWEI"/>
- </require>
- </extension>
- <extension name="VK_HUAWEI_invocation_mask" number="371" type="device" requires="VK_KHR_ray_tracing_pipeline,VK_KHR_synchronization2" author="Huawei" contact="Yunpeng Zhu @yunxingzhu" supported="vulkan">
- <require>
- <enum value="1" name="VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION"/>
- <enum value=""VK_HUAWEI_invocation_mask"" name="VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"/>
- <enum bitpos="39" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI"/>
- <enum bitpos="18" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"/>
- <enum bitpos="40" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI"/>
- <type name="VkPhysicalDeviceInvocationMaskFeaturesHUAWEI"/>
- <command name="vkCmdBindInvocationMaskHUAWEI"/>
- </require>
- </extension>
- <extension name="VK_NV_external_memory_rdma" number="372" type="device" requires="VK_KHR_external_memory" author="NV" contact="Carsten Rohde @crohde" supported="vulkan">
- <require>
- <enum value="1" name="VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION"/>
- <enum value=""VK_NV_external_memory_rdma"" name="VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"/>
- <enum bitpos="8" extends="VkMemoryPropertyFlagBits" name="VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"/>
- <enum bitpos="12" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV"/>
- <type name="VkRemoteAddressNV"/>
- <type name="VkMemoryGetRemoteAddressInfoNV"/>
- <type name="VkPhysicalDeviceExternalMemoryRDMAFeaturesNV"/>
- <command name="vkGetMemoryRemoteAddressNV"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_373" number="373" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_373_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_373"" name="VK_NV_EXTENSION_373_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_374" number="374" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_374_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_374"" name="VK_NV_EXTENSION_374_EXTENSION_NAME"/>
- <enum bitpos="4" extends="VkExternalFenceHandleTypeFlagBits" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_4_BIT_NV"/>
- <enum bitpos="5" extends="VkExternalFenceHandleTypeFlagBits" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_5_BIT_NV"/>
- <enum bitpos="5" extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_5_BIT_NV"/>
- <enum bitpos="6" extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_6_BIT_NV"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_375" number="375" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_375_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_375"" name="VK_NV_EXTENSION_375_EXTENSION_NAME"/>
- <enum bitpos="13" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_RESERVED_13_BIT_NV"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_376" number="376" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_376_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_376"" name="VK_EXT_EXTENSION_376_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_377" number="377" author="EXT" contact="Hugues Evrard @hevrard" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_377_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_377"" name="VK_EXT_EXTENSION_377_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extended_dynamic_state2" number="378" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION"/>
- <enum value=""VK_EXT_extended_dynamic_state2"" name="VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT"/>
- <enum offset="1" extends="VkDynamicState" name="VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT"/>
- <enum offset="2" extends="VkDynamicState" name="VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT"/>
- <enum offset="3" extends="VkDynamicState" name="VK_DYNAMIC_STATE_LOGIC_OP_EXT"/>
- <enum offset="4" extends="VkDynamicState" name="VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT"/>
- <type name="VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"/>
- <command name="vkCmdSetPatchControlPointsEXT"/>
- <command name="vkCmdSetRasterizerDiscardEnableEXT"/>
- <command name="vkCmdSetDepthBiasEnableEXT"/>
- <command name="vkCmdSetLogicOpEXT"/>
- <command name="vkCmdSetPrimitiveRestartEnableEXT"/>
- </require>
- </extension>
- <extension name="VK_QNX_screen_surface" number="379" type="instance" requires="VK_KHR_surface" platform="screen" author="QNX" contact="Mike Gorchak @mgorchak-blackberry" supported="vulkan">
- <require>
- <enum value="1" name="VK_QNX_SCREEN_SURFACE_SPEC_VERSION"/>
- <enum value=""VK_QNX_screen_surface"" name="VK_QNX_SCREEN_SURFACE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX"/>
- <type name="VkScreenSurfaceCreateFlagsQNX"/>
- <type name="VkScreenSurfaceCreateInfoQNX"/>
- <command name="vkCreateScreenSurfaceQNX"/>
- <command name="vkGetPhysicalDeviceScreenPresentationSupportQNX"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_380" number="380" author="KHR" contact="James Jones @cubanismo" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_380_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_380"" name="VK_KHR_EXTENSION_380_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_381" number="381" author="KHR" contact="James Jones @cubanismo" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_381_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_381"" name="VK_KHR_EXTENSION_381_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_color_write_enable" number="382" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Sharif Elcott @selcott" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION"/>
- <enum value=""VK_EXT_color_write_enable"" name="VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"/>
- <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT"/>
- <type name="VkPhysicalDeviceColorWriteEnableFeaturesEXT"/>
- <type name="VkPipelineColorWriteCreateInfoEXT"/>
- <command name="vkCmdSetColorWriteEnableEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_383" number="383" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_383_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_383"" name="VK_EXT_EXTENSION_383_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_384" number="384" type="instance" author="EXT" contact="Chia-I Wu @olvaffe1" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_384_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_384"" name="VK_EXT_EXTENSION_384_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_MESA_extension_385" number="385" type="instance" author="MESA" contact="Chia-I Wu @olvaffe1" supported="disabled">
- <require>
- <enum value="0" name="VK_MESA_EXTENSION_385_SPEC_VERSION"/>
- <enum value=""VK_MESA_extension_385"" name="VK_MESA_EXTENSION_385_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_extension_386" number="386" author="GOOGLE" contact="Chia-I Wu @olvaffe1" supported="disabled">
- <require>
- <enum value="0" name="VK_GOOGLE_EXTENSION_386_SPEC_VERSION"/>
- <enum value=""VK_GOOGLE_extension_386"" name="VK_GOOGLE_EXTENSION_386_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_387" number="387" author="KHR" contact="Daniel Koch @dgkoch" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_387_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_387"" name="VK_KHR_EXTENSION_387_EXTENSION_NAME"/>
- <enum bitpos="28" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_RESERVED_387_BIT_KHR"/>
- <enum bitpos="40" extends="VkAccessFlagBits2KHR" name="VK_ACCESS_2_RESERVED_387_BIT_KHR"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_388" number="388" author="EXT" contact="Alan Baker @alan-baker" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_388_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_388"" name="VK_EXT_EXTENSION_388_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_global_priority_query" number="389" type="device" requires="VK_EXT_global_priority,VK_KHR_get_physical_device_properties2" author="EXT" contact="Yiwei Zhang @zhangyiwei" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION"/>
- <enum value=""VK_EXT_global_priority_query"" name="VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT"/>
- <enum name="VK_MAX_GLOBAL_PRIORITY_SIZE_EXT"/>
- <type name="VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT"/>
- <type name="VkQueueFamilyGlobalPriorityPropertiesEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_390" number="390" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_390_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_390"" name="VK_EXT_EXTENSION_390_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_391" number="391" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_391_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_391"" name="VK_EXT_EXTENSION_391_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_392" number="392" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_392_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_392"" name="VK_EXT_EXTENSION_392_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_multi_draw" number="393" author="EXT" contact="Mike Blumenkrantz @zmike" type="device" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_MULTI_DRAW_SPEC_VERSION"/>
- <enum value=""VK_EXT_multi_draw"" name="VK_EXT_MULTI_DRAW_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"/>
- <type name="VkPhysicalDeviceMultiDrawFeaturesEXT"/>
- <type name="VkPhysicalDeviceMultiDrawPropertiesEXT"/>
- <command name="vkCmdDrawMultiEXT"/>
- <command name="vkCmdDrawMultiIndexedEXT"/>
- <type name="VkMultiDrawInfoEXT"/>
- <type name="VkMultiDrawIndexedInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_394" number="394" author="EXT" contact="Mike Blumenkrantz @zmike" type="device" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_394_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_394"" name="VK_EXT_EXTENSION_394_EXTENSION_NAME"/>
- <enum extends="VkImageCreateFlagBits" bitpos="17" name="VK_IMAGE_CREATE_RESERVED_394_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_395" number="395" author="KHR" contact="Lenny Komow @lkomow" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_395_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_395"" name="VK_KHR_EXTENSION_395_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_396" number="396" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_396_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_396"" name="VK_KHR_EXTENSION_396_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_397" number="397" author="NV" contact="Christoph Kubisch @pixeljetstream" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_397_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_397"" name="VK_NV_EXTENSION_397_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_398" number="398" author="NV" contact="Christoph Kubisch @pixeljetstream" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_398_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_398"" name="VK_NV_EXTENSION_398_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_JUICE_extension_399" number="399" author="JUICE" contact="Dean Beeler @canadacow" supported="disabled">
- <require>
- <enum value="0" name="VK_JUICE_EXTENSION_399_SPEC_VERSION"/>
- <enum value=""VK_JUICE_extension_399"" name="VK_JUICE_EXTENSION_399_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_JUICE_extension_400" number="400" author="JUICE" contact="David McCloskey @damcclos" supported="disabled">
- <require>
- <enum value="0" name="VK_JUICE_EXTENSION_400_SPEC_VERSION"/>
- <enum value=""VK_JUICE_extension_400"" name="VK_JUICE_EXTENSION_400_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_load_store_op_none" number="401" author="EXT" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION"/>
- <enum value=""VK_EXT_load_store_op_none"" name="VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkAttachmentLoadOp" name="VK_ATTACHMENT_LOAD_OP_NONE_EXT"/>
- <enum extends="VkAttachmentStoreOp" name="VK_ATTACHMENT_STORE_OP_NONE_EXT" alias="VK_ATTACHMENT_STORE_OP_NONE_KHR"/>
- </require>
- </extension>
- <extension name="VK_FB_extension_402" number="402" author="FB" contact="Artem Bolgar @artyom17" supported="disabled">
- <require>
- <enum value="0" name="VK_FB_EXTENSION_402_SPEC_VERSION"/>
- <enum value=""VK_FB_extension_402"" name="VK_FB_EXTENSION_402_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_FB_extension_403" number="403" author="FB" contact="Artem Bolgar @artyom17" supported="disabled">
- <require>
- <enum value="0" name="VK_FB_EXTENSION_403_SPEC_VERSION"/>
- <enum value=""VK_FB_extension_403"" name="VK_FB_EXTENSION_403_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_FB_extension_404" number="404" author="FB" contact="Artem Bolgar @artyom17" supported="disabled">
- <require>
- <enum value="0" name="VK_FB_EXTENSION_404_SPEC_VERSION"/>
- <enum value=""VK_FB_extension_404"" name="VK_FB_EXTENSION_404_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_HUAWEI_extension_405" number="405" author="HUAWEI" contact="Hueilong Wang @wyvernathuawei" supported="disabled">
- <require>
- <enum value="0" name="VK_HUAWEI_EXTENSION_405_SPEC_VERSION"/>
- <enum value=""VK_HUAWEI_extension_405"" name="VK_HUAWEI_EXTENSION_405_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_HUAWEI_extension_406" number="406" author="HUAWEI" contact="Hueilong Wang @wyvernathuawei" supported="disabled">
- <require>
- <enum value="0" name="VK_HUAWEI_EXTENSION_406_SPEC_VERSION"/>
- <enum value=""VK_HUAWEI_extension_406"" name="VK_HUAWEI_EXTENSION_406_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GGP_extension_407" number="407" author="GGP" contact="J.D. Rouan @jdrouan" supported="disabled">
- <require>
- <enum value="0" name="VK_GGP_EXTENSION_407_SPEC_VERSION"/>
- <enum value=""VK_GGP_extension_407"" name="VK_GGP_EXTENSION_407_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GGP_extension_408" number="408" author="GGP" contact="J.D. Rouan @jdrouan" supported="disabled">
- <require>
- <enum value="0" name="VK_GGP_EXTENSION_408_SPEC_VERSION"/>
- <enum value=""VK_GGP_extension_408"" name="VK_GGP_EXTENSION_408_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GGP_extension_409" number="409" author="GGP" contact="J.D. Rouan @jdrouan" supported="disabled">
- <require>
- <enum value="0" name="VK_GGP_EXTENSION_409_SPEC_VERSION"/>
- <enum value=""VK_GGP_extension_409"" name="VK_GGP_EXTENSION_409_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GGP_extension_410" number="410" author="GGP" contact="J.D. Rouan @jdrouan" supported="disabled">
- <require>
- <enum value="0" name="VK_GGP_EXTENSION_410_SPEC_VERSION"/>
- <enum value=""VK_GGP_extension_410"" name="VK_GGP_EXTENSION_410_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GGP_extension_411" number="411" author="GGP" contact="J.D. Rouan @jdrouan" supported="disabled">
- <require>
- <enum value="0" name="VK_GGP_EXTENSION_411_SPEC_VERSION"/>
- <enum value=""VK_GGP_extension_411"" name="VK_GGP_EXTENSION_411_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_border_color_swizzle" number="412" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan" requires="VK_EXT_custom_border_color" specialuse="glemulation,d3demulation">
- <require>
- <enum value="1" name="VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION"/>
- <enum value=""VK_EXT_border_color_swizzle"" name="VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"/>
- <type name="VkPhysicalDeviceBorderColorSwizzleFeaturesEXT"/>
- <type name="VkSamplerBorderColorComponentMappingCreateInfoEXT"/>
- </require>
- </extension>
- <extension name="VK_EXT_pageable_device_local_memory" number="413" author="EXT" contact="Piers Daniell @pdaniell-nv" type="device" requires="VK_EXT_memory_priority" supported="vulkan">
- <require>
- <enum value="1" name="VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION"/>
- <enum value=""VK_EXT_pageable_device_local_memory"" name="VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"/>
- <type name="VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT"/>
- <command name="vkSetDeviceMemoryPriorityEXT"/>
- </require>
- </extension>
- <extension name="VK_KHR_maintenance4" number="414" type="device" requiresCore="1.1" author="KHR" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
- <require>
- <enum value="1" name="VK_KHR_MAINTENANCE_4_SPEC_VERSION"/>
- <enum value=""VK_KHR_maintenance4"" name="VK_KHR_MAINTENANCE_4_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"/>
- <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"/>
- <type name="VkPhysicalDeviceMaintenance4FeaturesKHR"/>
- <type name="VkPhysicalDeviceMaintenance4PropertiesKHR"/>
- <type name="VkDeviceBufferMemoryRequirementsKHR"/>
- <type name="VkDeviceImageMemoryRequirementsKHR"/>
- <command name="vkGetDeviceBufferMemoryRequirementsKHR"/>
- <command name="vkGetDeviceImageMemoryRequirementsKHR"/>
- <command name="vkGetDeviceImageSparseMemoryRequirementsKHR"/>
- </require>
- </extension>
- <extension name="VK_HUAWEI_extension_415" number="415" author="HUAWEI" contact="Hueilong Wang @wyvernathuawei" supported="disabled">
- <require>
- <enum value="0" name="VK_HUAWEI_EXTENSION_415_SPEC_VERSION"/>
- <enum value=""VK_HUAWEI_extension_415"" name="VK_HUAWEI_EXTENSION_415_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_ARM_extension_416" number="416" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <enum value="0" name="VK_ARM_EXTENSION_416_SPEC_VERSION"/>
- <enum value=""VK_ARM_extension_416"" name="VK_ARM_EXTENSION_416_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_417" number="417" author="KHR" contact="Kevin Petit @kevinpetit" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_417_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_417"" name="VK_KHR_EXTENSION_417_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_ARM_extension_418" number="418" author="ARM" contact="Kevin Petit @kevinpetit" supported="disabled">
- <require>
- <enum value="0" name="VK_ARM_EXTENSION_418_SPEC_VERSION"/>
- <enum value=""VK_ARM_extension_418"" name="VK_ARM_EXTENSION_418_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_419" number="419" author="EXT" contact="Mike Blumenkrantz @zmike" type="device" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_419_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_419"" name="VK_EXT_EXTENSION_419_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_420" number="420" author="EXT" contact="Mike Blumenkrantz @zmike" type="device" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_420_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_420"" name="VK_EXT_EXTENSION_420_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_KHR_extension_421" number="421" author="KHR" contact="Hans-Kristian Arntzen @HansKristian-Work" supported="disabled">
- <require>
- <enum value="0" name="VK_KHR_EXTENSION_421_SPEC_VERSION"/>
- <enum value=""VK_KHR_extension_421"" name="VK_KHR_EXTENSION_421_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_extension_422" number="422" author="EXT" contact="Graeme Leese @gnl21" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_EXTENSION_422_SPEC_VERSION"/>
- <enum value=""VK_EXT_extension_422"" name="VK_EXT_EXTENSION_422_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_EXT_disable_cube_map_wrap" number="423" author="EXT" contact="Georg Lehmann @DadSchoorse" supported="disabled">
- <require>
- <enum value="0" name="VK_EXT_DISABLE_CUBE_MAP_WRAP_SPEC_VERSION"/>
- <enum value=""VK_EXT_disable_cube_map_wrap"" name="VK_EXT_DISABLE_CUBE_MAP_WRAP_EXTENSION_NAME"/>
- <enum bitpos="2" extends="VkSamplerCreateFlagBits" name="VK_SAMPLER_CREATE_RESERVED_2_BIT_EXT"/>
- </require>
- </extension>
- <extension name="VK_ARM_extension_424" number="424" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <enum value="0" name="VK_ARM_EXTENSION_424_SPEC_VERSION"/>
- <enum value=""VK_ARM_extension_424"" name="VK_ARM_EXTENSION_424_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_ARM_extension_425" number="425" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
- <require>
- <enum value="0" name="VK_ARM_EXTENSION_425_SPEC_VERSION"/>
- <enum value=""VK_ARM_extension_425"" name="VK_ARM_EXTENSION_425_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_QCOM_extension_426" number="426" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
- <require>
- <enum value="0" name="VK_QCOM_EXTENSION_426_SPEC_VERSION"/>
- <enum value=""VK_QCOM_extension_426"" name="VK_QCOM_EXTENSION_426_EXTENSION_NAME"/>
- <enum bitpos="15" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_427" number="427" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_427_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_427"" name="VK_NV_EXTENSION_427_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_428" number="428" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_428_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_428"" name="VK_NV_EXTENSION_428_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_429" number="429" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_429_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_429"" name="VK_NV_EXTENSION_429_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_430" number="430" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_430_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_430"" name="VK_NV_EXTENSION_430_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_431" number="431" author="NV" contact="Sourav Parmar @souravpNV" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_431_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_431"" name="VK_NV_EXTENSION_431_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_432" number="432" author="NV" contact="Sourav Parmar @souravpNV" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_432_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_432"" name="VK_NV_EXTENSION_432_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_NV_extension_433" number="433" author="NV" contact="Sourav Parmar @souravpNV" supported="disabled">
- <require>
- <enum value="0" name="VK_NV_EXTENSION_433_SPEC_VERSION"/>
- <enum value=""VK_NV_extension_433"" name="VK_NV_EXTENSION_433_EXTENSION_NAME"/>
- </require>
- </extension>
- <extension name="VK_GOOGLE_gfxstream" number="386" author="GOOGLE" contact="Lingfeng Yang @frank,Roman Kiryanov @rkir,Yilong Li @liyl_google" supported="vulkan">
- <require>
- <enum value="0" name="VK_GOOGLE_GFXSTREAM_SPEC_VERSION"/>
- <enum value="386" name="VK_GOOGLE_GFXSTREAM_NUMBER"/>
- <enum value=""VK_GOOGLE_gfxstream"" name="VK_GOOGLE_GFXSTREAM_EXTENSION_NAME"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE"/>
- <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_BUFFER_HANDLE_GOOGLE"/>
- <type name="VkImportColorBufferGOOGLE"/>
- <type name="VkImportBufferGOOGLE"/>
- <type name="VkImportPhysicalAddressGOOGLE"/>
- <command name="vkRegisterImageColorBufferGOOGLE"/>
- <command name="vkRegisterBufferColorBufferGOOGLE"/>
- <command name="vkMapMemoryIntoAddressSpaceGOOGLE"/>
- <command name="vkUpdateDescriptorSetWithTemplateSizedGOOGLE"/>
- <command name="vkBeginCommandBufferAsyncGOOGLE"/>
- <command name="vkEndCommandBufferAsyncGOOGLE"/>
- <command name="vkResetCommandBufferAsyncGOOGLE"/>
- <command name="vkCommandBufferHostSyncGOOGLE"/>
- <command name="vkCreateImageWithRequirementsGOOGLE"/>
- <command name="vkCreateBufferWithRequirementsGOOGLE"/>
- <command name="vkGetMemoryHostAddressInfoGOOGLE"/>
- <command name="vkFreeMemorySyncGOOGLE"/>
- <command name="vkQueueHostSyncGOOGLE"/>
- <command name="vkQueueSubmitAsyncGOOGLE"/>
- <command name="vkQueueWaitIdleAsyncGOOGLE"/>
- <command name="vkQueueBindSparseAsyncGOOGLE"/>
- <command name="vkGetLinearImageLayoutGOOGLE"/>
- <command name="vkQueueFlushCommandsGOOGLE"/>
- <command name="vkQueueCommitDescriptorSetUpdatesGOOGLE"/>
- <command name="vkCollectDescriptorPoolIdsGOOGLE"/>
- <command name="vkQueueSignalReleaseImageANDROIDAsyncGOOGLE"/>
- </require>
- </extension>
- </extensions>
- <spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it">
- <spirvextension name="SPV_KHR_variable_pointers">
- <enable version="VK_API_VERSION_1_1"/>
- <enable extension="VK_KHR_variable_pointers"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_shader_explicit_vertex_parameter">
- <enable extension="VK_AMD_shader_explicit_vertex_parameter"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_gcn_shader">
- <enable extension="VK_AMD_gcn_shader"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_gpu_shader_half_float">
- <enable extension="VK_AMD_gpu_shader_half_float"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_gpu_shader_int16">
- <enable extension="VK_AMD_gpu_shader_int16"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_shader_ballot">
- <enable extension="VK_AMD_shader_ballot"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_shader_fragment_mask">
- <enable extension="VK_AMD_shader_fragment_mask"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_shader_image_load_store_lod">
- <enable extension="VK_AMD_shader_image_load_store_lod"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_shader_trinary_minmax">
- <enable extension="VK_AMD_shader_trinary_minmax"/>
- </spirvextension>
- <spirvextension name="SPV_AMD_texture_gather_bias_lod">
- <enable extension="VK_AMD_texture_gather_bias_lod"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_shader_draw_parameters">
- <enable version="VK_API_VERSION_1_1"/>
- <enable extension="VK_KHR_shader_draw_parameters"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_8bit_storage">
- <enable version="VK_API_VERSION_1_2"/>
- <enable extension="VK_KHR_8bit_storage"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_16bit_storage">
- <enable version="VK_API_VERSION_1_1"/>
- <enable extension="VK_KHR_16bit_storage"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_shader_clock">
- <enable extension="VK_KHR_shader_clock"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_float_controls">
- <enable version="VK_API_VERSION_1_2"/>
- <enable extension="VK_KHR_shader_float_controls"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_storage_buffer_storage_class">
- <enable version="VK_API_VERSION_1_1"/>
- <enable extension="VK_KHR_storage_buffer_storage_class"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_post_depth_coverage">
- <enable extension="VK_EXT_post_depth_coverage"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_shader_stencil_export">
- <enable extension="VK_EXT_shader_stencil_export"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_shader_ballot">
- <enable extension="VK_EXT_shader_subgroup_ballot"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_subgroup_vote">
- <enable extension="VK_EXT_shader_subgroup_vote"/>
- </spirvextension>
- <spirvextension name="SPV_NV_sample_mask_override_coverage">
- <enable extension="VK_NV_sample_mask_override_coverage"/>
- </spirvextension>
- <spirvextension name="SPV_NV_geometry_shader_passthrough">
- <enable extension="VK_NV_geometry_shader_passthrough"/>
- </spirvextension>
- <spirvextension name="SPV_NV_mesh_shader">
- <enable extension="VK_NV_mesh_shader"/>
- </spirvextension>
- <spirvextension name="SPV_NV_viewport_array2">
- <enable extension="VK_NV_viewport_array2"/>
- </spirvextension>
- <spirvextension name="SPV_NV_shader_subgroup_partitioned">
- <enable extension="VK_NV_shader_subgroup_partitioned"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_shader_viewport_index_layer">
- <enable version="VK_API_VERSION_1_2"/>
- <enable extension="VK_EXT_shader_viewport_index_layer"/>
- </spirvextension>
- <spirvextension name="SPV_NVX_multiview_per_view_attributes">
- <enable extension="VK_NVX_multiview_per_view_attributes"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_descriptor_indexing">
- <enable version="VK_API_VERSION_1_2"/>
- <enable extension="VK_EXT_descriptor_indexing"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_vulkan_memory_model">
- <enable version="VK_API_VERSION_1_2"/>
- <enable extension="VK_KHR_vulkan_memory_model"/>
- </spirvextension>
- <spirvextension name="SPV_NV_compute_shader_derivatives">
- <enable extension="VK_NV_compute_shader_derivatives"/>
- </spirvextension>
- <spirvextension name="SPV_NV_fragment_shader_barycentric">
- <enable extension="VK_NV_fragment_shader_barycentric"/>
- </spirvextension>
- <spirvextension name="SPV_NV_shader_image_footprint">
- <enable extension="VK_NV_shader_image_footprint"/>
- </spirvextension>
- <spirvextension name="SPV_NV_shading_rate">
- <enable extension="VK_NV_shading_rate_image"/>
- </spirvextension>
- <spirvextension name="SPV_NV_ray_tracing">
- <enable extension="VK_NV_ray_tracing"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_ray_tracing">
- <enable extension="VK_KHR_ray_tracing_pipeline"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_ray_query">
- <enable extension="VK_KHR_ray_query"/>
- </spirvextension>
- <spirvextension name="SPV_GOOGLE_hlsl_functionality1">
- <enable extension="VK_GOOGLE_hlsl_functionality1"/>
- </spirvextension>
- <spirvextension name="SPV_GOOGLE_user_type">
- <enable extension="VK_GOOGLE_user_type"/>
- </spirvextension>
- <spirvextension name="SPV_GOOGLE_decorate_string">
- <enable extension="VK_GOOGLE_decorate_string"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_fragment_invocation_density">
- <enable extension="VK_EXT_fragment_density_map"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_physical_storage_buffer">
- <enable version="VK_API_VERSION_1_2"/>
- <enable extension="VK_KHR_buffer_device_address"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_physical_storage_buffer">
- <enable extension="VK_EXT_buffer_device_address"/>
- </spirvextension>
- <spirvextension name="SPV_NV_cooperative_matrix">
- <enable extension="VK_NV_cooperative_matrix"/>
- </spirvextension>
- <spirvextension name="SPV_NV_shader_sm_builtins">
- <enable extension="VK_NV_shader_sm_builtins"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_fragment_shader_interlock">
- <enable extension="VK_EXT_fragment_shader_interlock"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_demote_to_helper_invocation">
- <enable extension="VK_EXT_shader_demote_to_helper_invocation"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_fragment_shading_rate">
- <enable extension="VK_KHR_fragment_shading_rate"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_non_semantic_info">
- <enable extension="VK_KHR_shader_non_semantic_info"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_shader_image_int64">
- <enable extension="VK_EXT_shader_image_atomic_int64"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_terminate_invocation">
- <enable extension="VK_KHR_shader_terminate_invocation"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_multiview">
- <enable version="VK_API_VERSION_1_1"/>
- <enable extension="VK_KHR_multiview"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_workgroup_memory_explicit_layout">
- <enable extension="VK_KHR_workgroup_memory_explicit_layout"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_shader_atomic_float_add">
- <enable extension="VK_EXT_shader_atomic_float"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_subgroup_uniform_control_flow">
- <enable extension="VK_KHR_shader_subgroup_uniform_control_flow"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_shader_atomic_float_min_max">
- <enable extension="VK_EXT_shader_atomic_float2"/>
- </spirvextension>
- <spirvextension name="SPV_EXT_shader_atomic_float16_add">
- <enable extension="VK_EXT_shader_atomic_float2"/>
- </spirvextension>
- <spirvextension name="SPV_KHR_integer_dot_product">
- <enable extension="VK_KHR_shader_integer_dot_product"/>
- </spirvextension>
- </spirvextensions>
- <spirvcapabilities comment="SPIR-V Capabilities allowed in Vulkan and what is required to use it">
- <spirvcapability name="Matrix">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Shader">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="InputAttachment">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Sampled1D">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Image1D">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="SampledBuffer">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="ImageBuffer">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="ImageQuery">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="DerivativeControl">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Geometry">
- <enable struct="VkPhysicalDeviceFeatures" feature="geometryShader" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Tessellation">
- <enable struct="VkPhysicalDeviceFeatures" feature="tessellationShader" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Float64">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderFloat64" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Int64">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderInt64" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="Int64Atomics">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderBufferInt64Atomics" requires="VK_VERSION_1_2,VK_KHR_shader_atomic_int64"/>
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderSharedInt64Atomics" requires="VK_VERSION_1_2,VK_KHR_shader_atomic_int64"/>
- <enable struct="VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT" feature="shaderImageInt64Atomics" requires="VK_EXT_shader_image_atomic_int64"/>
- </spirvcapability>
- <spirvcapability name="AtomicFloat16AddEXT">
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderBufferFloat16AtomicAdd" requires="VK_EXT_shader_atomic_float2"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderSharedFloat16AtomicAdd" requires="VK_EXT_shader_atomic_float2"/>
- </spirvcapability>
- <spirvcapability name="AtomicFloat32AddEXT">
- <enable struct="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT" feature="shaderBufferFloat32AtomicAdd" requires="VK_EXT_shader_atomic_float"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT" feature="shaderSharedFloat32AtomicAdd" requires="VK_EXT_shader_atomic_float"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT" feature="shaderImageFloat32AtomicAdd" requires="VK_EXT_shader_atomic_float"/>
- </spirvcapability>
- <spirvcapability name="AtomicFloat64AddEXT">
- <enable struct="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT" feature="shaderBufferFloat64AtomicAdd" requires="VK_EXT_shader_atomic_float"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT" feature="shaderSharedFloat64AtomicAdd" requires="VK_EXT_shader_atomic_float"/>
- </spirvcapability>
- <spirvcapability name="AtomicFloat16MinMaxEXT">
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderBufferFloat16AtomicMinMax" requires="VK_EXT_shader_atomic_float2"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderSharedFloat16AtomicMinMax" requires="VK_EXT_shader_atomic_float2"/>
- </spirvcapability>
- <spirvcapability name="AtomicFloat32MinMaxEXT">
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderBufferFloat32AtomicMinMax" requires="VK_EXT_shader_atomic_float2"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderSharedFloat32AtomicMinMax" requires="VK_EXT_shader_atomic_float2"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderImageFloat32AtomicMinMax" requires="VK_EXT_shader_atomic_float2"/>
- </spirvcapability>
- <spirvcapability name="AtomicFloat64MinMaxEXT">
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderBufferFloat64AtomicMinMax" requires="VK_EXT_shader_atomic_float2"/>
- <enable struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT" feature="shaderSharedFloat64AtomicMinMax" requires="VK_EXT_shader_atomic_float2"/>
- </spirvcapability>
- <spirvcapability name="Int64ImageEXT">
- <enable struct="VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT" feature="shaderImageInt64Atomics" requires="VK_EXT_shader_image_atomic_int64"/>
- </spirvcapability>
- <spirvcapability name="Int16">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderInt16" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="TessellationPointSize">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderTessellationAndGeometryPointSize" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="GeometryPointSize">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderTessellationAndGeometryPointSize" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="ImageGatherExtended">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderImageGatherExtended" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="StorageImageMultisample">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderStorageImageMultisample" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="UniformBufferArrayDynamicIndexing">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderUniformBufferArrayDynamicIndexing" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="SampledImageArrayDynamicIndexing">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderSampledImageArrayDynamicIndexing" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="StorageBufferArrayDynamicIndexing">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderStorageBufferArrayDynamicIndexing" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="StorageImageArrayDynamicIndexing">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderStorageImageArrayDynamicIndexing" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="ClipDistance">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderClipDistance" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="CullDistance">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderCullDistance" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="ImageCubeArray">
- <enable struct="VkPhysicalDeviceFeatures" feature="imageCubeArray" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="SampleRateShading">
- <enable struct="VkPhysicalDeviceFeatures" feature="sampleRateShading" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="SparseResidency">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderResourceResidency" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="MinLod">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderResourceMinLod" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="SampledCubeArray">
- <enable struct="VkPhysicalDeviceFeatures" feature="imageCubeArray" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="ImageMSArray">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderStorageImageMultisample" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="StorageImageExtendedFormats">
- <enable version="VK_API_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="InterpolationFunction">
- <enable struct="VkPhysicalDeviceFeatures" feature="sampleRateShading" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="StorageImageReadWithoutFormat">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderStorageImageReadWithoutFormat" requires="VK_VERSION_1_0"/>
- <enable extension="VK_KHR_format_feature_flags2"/>
- </spirvcapability>
- <spirvcapability name="StorageImageWriteWithoutFormat">
- <enable struct="VkPhysicalDeviceFeatures" feature="shaderStorageImageWriteWithoutFormat" requires="VK_VERSION_1_0"/>
- <enable extension="VK_KHR_format_feature_flags2"/>
- </spirvcapability>
- <spirvcapability name="MultiViewport">
- <enable struct="VkPhysicalDeviceFeatures" feature="multiViewport" requires="VK_VERSION_1_0"/>
- </spirvcapability>
- <spirvcapability name="DrawParameters">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="shaderDrawParameters" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDeviceShaderDrawParametersFeatures" feature="shaderDrawParameters" requires="VK_VERSION_1_1"/>
- <enable extension="VK_KHR_shader_draw_parameters"/>
- </spirvcapability>
- <spirvcapability name="MultiView">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="multiview" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDeviceMultiviewFeatures" feature="multiview" requires="VK_KHR_multiview"/>
- </spirvcapability>
- <spirvcapability name="DeviceGroup">
- <enable version="VK_API_VERSION_1_1"/>
- <enable extension="VK_KHR_device_group"/>
- </spirvcapability>
- <spirvcapability name="VariablePointersStorageBuffer">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="variablePointersStorageBuffer" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDeviceVariablePointersFeatures" feature="variablePointersStorageBuffer" requires="VK_KHR_variable_pointers"/>
- </spirvcapability>
- <spirvcapability name="VariablePointers">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="variablePointers" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDeviceVariablePointersFeatures" feature="variablePointers" requires="VK_KHR_variable_pointers"/>
- </spirvcapability>
- <spirvcapability name="ShaderClockKHR">
- <enable extension="VK_KHR_shader_clock"/>
- </spirvcapability>
- <spirvcapability name="StencilExportEXT">
- <enable extension="VK_EXT_shader_stencil_export"/>
- </spirvcapability>
- <spirvcapability name="SubgroupBallotKHR">
- <enable extension="VK_EXT_shader_subgroup_ballot"/>
- </spirvcapability>
- <spirvcapability name="SubgroupVoteKHR">
- <enable extension="VK_EXT_shader_subgroup_vote"/>
- </spirvcapability>
- <spirvcapability name="ImageReadWriteLodAMD">
- <enable extension="VK_AMD_shader_image_load_store_lod"/>
- </spirvcapability>
- <spirvcapability name="ImageGatherBiasLodAMD">
- <enable extension="VK_AMD_texture_gather_bias_lod"/>
- </spirvcapability>
- <spirvcapability name="FragmentMaskAMD">
- <enable extension="VK_AMD_shader_fragment_mask"/>
- </spirvcapability>
- <spirvcapability name="SampleMaskOverrideCoverageNV">
- <enable extension="VK_NV_sample_mask_override_coverage"/>
- </spirvcapability>
- <spirvcapability name="GeometryShaderPassthroughNV">
- <enable extension="VK_NV_geometry_shader_passthrough"/>
- </spirvcapability>
- <spirvcapability name="ShaderViewportIndex">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderOutputViewportIndex" requires="VK_VERSION_1_2"/>
- </spirvcapability>
- <spirvcapability name="ShaderLayer">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderOutputLayer" requires="VK_VERSION_1_2"/>
- </spirvcapability>
- <spirvcapability name="ShaderViewportIndexLayerEXT">
- <enable extension="VK_EXT_shader_viewport_index_layer"/>
- </spirvcapability>
- <spirvcapability name="ShaderViewportIndexLayerNV">
- <enable extension="VK_NV_viewport_array2"/>
- </spirvcapability>
- <spirvcapability name="ShaderViewportMaskNV">
- <enable extension="VK_NV_viewport_array2"/>
- </spirvcapability>
- <spirvcapability name="PerViewAttributesNV">
- <enable extension="VK_NVX_multiview_per_view_attributes"/>
- </spirvcapability>
- <spirvcapability name="StorageBuffer16BitAccess">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="storageBuffer16BitAccess" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDevice16BitStorageFeatures" feature="storageBuffer16BitAccess" requires="VK_KHR_16bit_storage"/>
- </spirvcapability>
- <spirvcapability name="UniformAndStorageBuffer16BitAccess">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="uniformAndStorageBuffer16BitAccess" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDevice16BitStorageFeatures" feature="uniformAndStorageBuffer16BitAccess" requires="VK_KHR_16bit_storage"/>
- </spirvcapability>
- <spirvcapability name="StoragePushConstant16">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="storagePushConstant16" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDevice16BitStorageFeatures" feature="storagePushConstant16" requires="VK_KHR_16bit_storage"/>
- </spirvcapability>
- <spirvcapability name="StorageInputOutput16">
- <enable struct="VkPhysicalDeviceVulkan11Features" feature="storageInputOutput16" requires="VK_VERSION_1_2"/>
- <enable struct="VkPhysicalDevice16BitStorageFeatures" feature="storageInputOutput16" requires="VK_KHR_16bit_storage"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniform">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_BASIC_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformVote">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_VOTE_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformArithmetic">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_ARITHMETIC_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformBallot">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_BALLOT_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformShuffle">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_SHUFFLE_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformShuffleRelative">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformClustered">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_CLUSTERED_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformQuad">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_QUAD_BIT" requires="VK_VERSION_1_1"/>
- </spirvcapability>
- <spirvcapability name="GroupNonUniformPartitionedNV">
- <enable property="VkPhysicalDeviceVulkan11Properties" member="subgroupSupportedOperations" value="VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV" requires="VK_NV_shader_subgroup_partitioned"/>
- </spirvcapability>
- <spirvcapability name="SampleMaskPostDepthCoverage">
- <enable extension="VK_EXT_post_depth_coverage"/>
- </spirvcapability>
- <spirvcapability name="ShaderNonUniform">
- <enable version="VK_API_VERSION_1_2"/>
- <enable extension="VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="RuntimeDescriptorArray">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="runtimeDescriptorArray" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="InputAttachmentArrayDynamicIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderInputAttachmentArrayDynamicIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="UniformTexelBufferArrayDynamicIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderUniformTexelBufferArrayDynamicIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="StorageTexelBufferArrayDynamicIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderStorageTexelBufferArrayDynamicIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="UniformBufferArrayNonUniformIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderUniformBufferArrayNonUniformIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="SampledImageArrayNonUniformIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderSampledImageArrayNonUniformIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="StorageBufferArrayNonUniformIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderStorageBufferArrayNonUniformIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="StorageImageArrayNonUniformIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderStorageImageArrayNonUniformIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="InputAttachmentArrayNonUniformIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderInputAttachmentArrayNonUniformIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="UniformTexelBufferArrayNonUniformIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderUniformTexelBufferArrayNonUniformIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="StorageTexelBufferArrayNonUniformIndexing">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderStorageTexelBufferArrayNonUniformIndexing" requires="VK_VERSION_1_2,VK_EXT_descriptor_indexing"/>
- </spirvcapability>
- <spirvcapability name="Float16">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderFloat16" requires="VK_VERSION_1_2,VK_KHR_shader_float16_int8"/>
- <enable extension="VK_AMD_gpu_shader_half_float"/>
- </spirvcapability>
- <spirvcapability name="Int8">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="shaderInt8" requires="VK_VERSION_1_2,VK_KHR_shader_float16_int8"/>
- </spirvcapability>
- <spirvcapability name="StorageBuffer8BitAccess">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="storageBuffer8BitAccess" requires="VK_VERSION_1_2,VK_KHR_8bit_storage"/>
- </spirvcapability>
- <spirvcapability name="UniformAndStorageBuffer8BitAccess">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="uniformAndStorageBuffer8BitAccess" requires="VK_VERSION_1_2,VK_KHR_8bit_storage"/>
- </spirvcapability>
- <spirvcapability name="StoragePushConstant8">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="storagePushConstant8" requires="VK_VERSION_1_2,VK_KHR_8bit_storage"/>
- </spirvcapability>
- <spirvcapability name="VulkanMemoryModel">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="vulkanMemoryModel" requires="VK_VERSION_1_2,VK_KHR_vulkan_memory_model"/>
- </spirvcapability>
- <spirvcapability name="VulkanMemoryModelDeviceScope">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="vulkanMemoryModelDeviceScope" requires="VK_VERSION_1_2,VK_KHR_vulkan_memory_model"/>
- </spirvcapability>
- <spirvcapability name="DenormPreserve">
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormPreserveFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormPreserveFloat32" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormPreserveFloat64" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- </spirvcapability>
- <spirvcapability name="DenormFlushToZero">
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormFlushToZeroFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormFlushToZeroFloat32" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormFlushToZeroFloat64" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- </spirvcapability>
- <spirvcapability name="SignedZeroInfNanPreserve">
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderSignedZeroInfNanPreserveFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderSignedZeroInfNanPreserveFloat32" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderSignedZeroInfNanPreserveFloat64" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- </spirvcapability>
- <spirvcapability name="RoundingModeRTE">
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderRoundingModeRTEFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderRoundingModeRTEFloat32" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderRoundingModeRTEFloat64" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- </spirvcapability>
- <spirvcapability name="RoundingModeRTZ">
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderRoundingModeRTZFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderRoundingModeRTZFloat32" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderRoundingModeRTZFloat64" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
- </spirvcapability>
- <spirvcapability name="ComputeDerivativeGroupQuadsNV">
- <enable struct="VkPhysicalDeviceComputeShaderDerivativesFeaturesNV" feature="computeDerivativeGroupQuads" requires="VK_NV_compute_shader_derivatives"/>
- </spirvcapability>
- <spirvcapability name="ComputeDerivativeGroupLinearNV">
- <enable struct="VkPhysicalDeviceComputeShaderDerivativesFeaturesNV" feature="computeDerivativeGroupLinear" requires="VK_NV_compute_shader_derivatives"/>
- </spirvcapability>
- <spirvcapability name="FragmentBarycentricNV">
- <enable struct="VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV" feature="fragmentShaderBarycentric" requires="VK_NV_fragment_shader_barycentric"/>
- </spirvcapability>
- <spirvcapability name="ImageFootprintNV">
- <enable struct="VkPhysicalDeviceShaderImageFootprintFeaturesNV" feature="imageFootprint" requires="VK_NV_shader_image_footprint"/>
- </spirvcapability>
- <spirvcapability name="ShadingRateNV">
- <enable struct="VkPhysicalDeviceShadingRateImageFeaturesNV" feature="shadingRateImage" requires="VK_NV_shading_rate_image"/>
- </spirvcapability>
- <spirvcapability name="MeshShadingNV">
- <enable extension="VK_NV_mesh_shader"/>
- </spirvcapability>
- <spirvcapability name="RayTracingKHR">
- <enable struct="VkPhysicalDeviceRayTracingPipelineFeaturesKHR" feature="rayTracingPipeline" requires="VK_KHR_ray_tracing_pipeline"/>
- </spirvcapability>
- <spirvcapability name="RayQueryKHR">
- <enable struct="VkPhysicalDeviceRayQueryFeaturesKHR" feature="rayQuery" requires="VK_KHR_ray_query"/>
- </spirvcapability>
- <spirvcapability name="RayTraversalPrimitiveCullingKHR">
- <enable struct="VkPhysicalDeviceRayTracingPipelineFeaturesKHR" feature="rayTraversalPrimitiveCulling" requires="VK_KHR_ray_tracing_pipeline"/>
- </spirvcapability>
- <spirvcapability name="RayTracingNV">
- <enable extension="VK_NV_ray_tracing"/>
- </spirvcapability>
- <spirvcapability name="RayTracingMotionBlurNV">
- <enable struct="VkPhysicalDeviceRayTracingMotionBlurFeaturesNV" feature="rayTracingMotionBlur" requires="VK_NV_ray_tracing_motion_blur"/>
- </spirvcapability>
- <spirvcapability name="TransformFeedback">
- <enable struct="VkPhysicalDeviceTransformFeedbackFeaturesEXT" feature="transformFeedback" requires="VK_EXT_transform_feedback"/>
- </spirvcapability>
- <spirvcapability name="GeometryStreams">
- <enable struct="VkPhysicalDeviceTransformFeedbackFeaturesEXT" feature="geometryStreams" requires="VK_EXT_transform_feedback"/>
- </spirvcapability>
- <spirvcapability name="FragmentDensityEXT">
- <enable struct="VkPhysicalDeviceFragmentDensityMapFeaturesEXT" feature="fragmentDensityMap" requires="VK_EXT_fragment_density_map"/>
- </spirvcapability>
- <spirvcapability name="PhysicalStorageBufferAddresses">
- <enable struct="VkPhysicalDeviceVulkan12Features" feature="bufferDeviceAddress" requires="VK_VERSION_1_2,VK_KHR_buffer_device_address"/>
- <enable struct="VkPhysicalDeviceBufferDeviceAddressFeaturesEXT" feature="bufferDeviceAddress" requires="VK_EXT_buffer_device_address" alias="bufferDeviceAddressEXT"/>
- </spirvcapability>
- <spirvcapability name="CooperativeMatrixNV">
- <enable struct="VkPhysicalDeviceCooperativeMatrixFeaturesNV" feature="cooperativeMatrix" requires="VK_NV_cooperative_matrix"/>
- </spirvcapability>
- <spirvcapability name="IntegerFunctions2INTEL">
- <enable struct="VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL" feature="shaderIntegerFunctions2" requires="VK_INTEL_shader_integer_functions2"/>
- </spirvcapability>
- <spirvcapability name="ShaderSMBuiltinsNV">
- <enable struct="VkPhysicalDeviceShaderSMBuiltinsFeaturesNV" feature="shaderSMBuiltins" requires="VK_NV_shader_sm_builtins"/>
- </spirvcapability>
- <spirvcapability name="FragmentShaderSampleInterlockEXT">
- <enable struct="VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT" feature="fragmentShaderSampleInterlock" requires="VK_EXT_fragment_shader_interlock"/>
- </spirvcapability>
- <spirvcapability name="FragmentShaderPixelInterlockEXT">
- <enable struct="VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT" feature="fragmentShaderPixelInterlock" requires="VK_EXT_fragment_shader_interlock"/>
- </spirvcapability>
- <spirvcapability name="FragmentShaderShadingRateInterlockEXT">
- <enable struct="VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT" feature="fragmentShaderShadingRateInterlock" requires="VK_EXT_fragment_shader_interlock"/>
- <enable struct="VkPhysicalDeviceShadingRateImageFeaturesNV" feature="shadingRateImage" requires="VK_NV_shading_rate_image"/>
- </spirvcapability>
- <spirvcapability name="DemoteToHelperInvocationEXT">
- <enable struct="VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT" feature="shaderDemoteToHelperInvocation" requires="VK_EXT_shader_demote_to_helper_invocation"/>
- </spirvcapability>
- <spirvcapability name="FragmentShadingRateKHR">
- <enable struct="VkPhysicalDeviceFragmentShadingRateFeaturesKHR" feature="pipelineFragmentShadingRate" requires="VK_KHR_fragment_shading_rate"/>
- <enable struct="VkPhysicalDeviceFragmentShadingRateFeaturesKHR" feature="primitiveFragmentShadingRate" requires="VK_KHR_fragment_shading_rate"/>
- <enable struct="VkPhysicalDeviceFragmentShadingRateFeaturesKHR" feature="attachmentFragmentShadingRate" requires="VK_KHR_fragment_shading_rate"/>
- </spirvcapability>
- <spirvcapability name="WorkgroupMemoryExplicitLayoutKHR">
- <enable struct="VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR" feature="workgroupMemoryExplicitLayout" requires="VK_KHR_workgroup_memory_explicit_layout"/>
- </spirvcapability>
- <spirvcapability name="WorkgroupMemoryExplicitLayout8BitAccessKHR">
- <enable struct="VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR" feature="workgroupMemoryExplicitLayout8BitAccess" requires="VK_KHR_workgroup_memory_explicit_layout"/>
- </spirvcapability>
- <spirvcapability name="WorkgroupMemoryExplicitLayout16BitAccessKHR">
- <enable struct="VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR" feature="workgroupMemoryExplicitLayout16BitAccess" requires="VK_KHR_workgroup_memory_explicit_layout"/>
- </spirvcapability>
- <spirvcapability name="DotProductInputAllKHR">
- <enable struct="VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR" feature="shaderIntegerDotProduct" requires="VK_KHR_shader_integer_dot_product"/>
- </spirvcapability>
- <spirvcapability name="DotProductInput4x8BitKHR">
- <enable struct="VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR" feature="shaderIntegerDotProduct" requires="VK_KHR_shader_integer_dot_product"/>
- </spirvcapability>
- <spirvcapability name="DotProductInput4x8BitPackedKHR">
- <enable struct="VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR" feature="shaderIntegerDotProduct" requires="VK_KHR_shader_integer_dot_product"/>
- </spirvcapability>
- <spirvcapability name="DotProductKHR">
- <enable struct="VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR" feature="shaderIntegerDotProduct" requires="VK_KHR_shader_integer_dot_product"/>
- </spirvcapability>
- </spirvcapabilities>
-</registry>
diff --git a/guest/vulkan/vk_icd_gen.py b/guest/vulkan/vk_icd_gen.py
deleted file mode 100644
index d5401e8..0000000
--- a/guest/vulkan/vk_icd_gen.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# Copyright 2017 Intel Corporation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sub license, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice (including the
-# next paragraph) shall be included in all copies or substantial portions
-# of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
-# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
-# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-import argparse
-import json
-import os.path
-import re
-import xml.etree.ElementTree as et
-
-def get_xml_patch_version(xml_file):
- xml = et.parse(xml_file)
- for d in xml.findall('.types/type'):
- if d.get('category', None) != 'define':
- continue
-
- name = d.find('.name')
- if name.text != 'VK_HEADER_VERSION':
- continue;
-
- return name.tail.strip()
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser()
- parser.add_argument('--api-version', required=True,
- help='Vulkan API version.')
- parser.add_argument('--xml', required=False,
- help='Vulkan registry XML for patch version')
- parser.add_argument('--lib-path', required=True,
- help='Path to installed library')
- parser.add_argument('--out', required=False,
- help='Output json file.')
- args = parser.parse_args()
-
- version = args.api_version
- if args.xml:
- re.match(r'\d+\.\d+', version)
- version = version + '.' + get_xml_patch_version(args.xml)
- else:
- re.match(r'\d+\.\d+\.\d+', version)
-
- json_data = {
- 'file_format_version': '1.0.0',
- 'ICD': {
- 'library_path': args.lib_path,
- 'api_version': version,
- },
- }
-
- json_params = {
- 'indent': 4,
- 'sort_keys': True,
- 'separators': (',', ': '),
- }
-
- if args.out:
- with open(args.out, 'w') as f:
- json.dump(json_data, f, **json_params)
- else:
- print(json.dumps(json_data, **json_params))
diff --git a/guest/vulkan_enc/Android.bp b/guest/vulkan_enc/Android.bp
index 09cd26e..031ebad 100644
--- a/guest/vulkan_enc/Android.bp
+++ b/guest/vulkan_enc/Android.bp
@@ -19,46 +19,69 @@
default_applicable_licenses: ["hardware_google_gfxstream_license"],
}
+genrule {
+ name: "gfxstream_vk_entrypoints_header",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["gfxstream_vk_entrypoints.h"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(location gfxstream_vk_entrypoints.h) --out-c " +
+ "$(genDir)/placeholder.c --prefix gfxstream_vk --beta false",
+}
-cc_defaults {
- name: "libgfxstream_guest_vulkan_encoder_defaults",
+genrule {
+ name: "gfxstream_vk_entrypoints_impl",
+ srcs: [":libmesa_vulkan_xml"],
+ out: ["gfxstream_vk_entrypoints.c"],
+ tools: ["vk_entrypoints_gen"],
+ cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+ "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+ "$(genDir)/gfxstream_vk_entrypoints.h --out-c " +
+ "$(location gfxstream_vk_entrypoints.c) --prefix gfxstream_vk " +
+ "--beta false",
+}
+
+cc_library_static {
+ name: "libgfxstream_guest_vulkan_entrypoints",
host_supported: true,
vendor: true,
defaults: [
- "libgfxstream_guest_cc_defaults",
+ "mesa_common_defaults_gfxstream",
],
header_libs: [
- "gfxstream_vulkan_headers",
- "libgfxstream_guest_graphics_headers",
- "libgfxstream_guest_iostream",
- "libnativewindow_headers",
- ],
- shared_libs: [
- "libandroidemu",
- "libcutils",
- "liblog",
- "libOpenglCodecCommon",
- "lib_renderControl_enc",
+ "mesa_common_headers_gfxstream",
],
static_libs: [
- "libarect",
- "libdrm",
- "libGoldfishAddressSpace",
- "libgfxstream_guest_gralloc",
+ "libmesa_vulkan_util_gfxstream",
],
- cflags: [
- "-DLOG_TAG=\"goldfish_vulkan\"",
- "-DVIRTIO_GPU",
- "-DVK_ANDROID_native_buffer",
- "-DVK_EXT_device_memory_report",
- "-DVK_GOOGLE_gfxstream",
- "-DVK_NO_PROTOTYPES",
- "-DVK_USE_PLATFORM_ANDROID_KHR",
- "-fstrict-aliasing",
- "-Werror",
- "-Wno-missing-field-initializers",
- "-Wno-unused-parameter",
+ shared_libs: [
+ "libcutils",
],
+ generated_headers: [
+ "gfxstream_vk_entrypoints_header",
+ ],
+ generated_sources: [
+ "gfxstream_vk_entrypoints_impl",
+ ],
+ ldflags: [
+ "-Wl,-Bsymbolic",
+ "-Wl,--gc-sections",
+ ],
+ export_generated_headers: [
+ "gfxstream_vk_entrypoints_header",
+ ],
+}
+
+cc_library_headers {
+ name: "vulkan_enc_headers",
+ export_include_dirs: ["."],
+ host_supported: true,
+ vendor_available: true,
+}
+
+filegroup {
+ name: "vulkan_enc_impl",
srcs: [
"AndroidHardwareBuffer.cpp",
"CommandBufferStagingStream.cpp",
@@ -77,10 +100,76 @@
"VkEncoder.cpp",
"VulkanHandleMapping.cpp",
"VulkanStreamGuest.cpp",
+ "gfxstream_vk_private.cpp",
+ ],
+}
+
+cc_defaults {
+ name: "libgfxstream_guest_vulkan_encoder_defaults",
+ host_supported: true,
+ vendor: true,
+ defaults: [
+ "libgfxstream_guest_cc_defaults",
+ ],
+ header_libs: [
+ "gfxstream_vulkan_headers",
+ "libgfxstream_guest_iostream",
+ "libnativewindow_headers",
+ "mesa_common_headers_gfxstream",
+ ],
+ generated_headers: [
+ "vk_cmd_queue_header",
+ "vk_physical_device_features_header",
+ "vk_physical_device_properties_header",
+ "u_format_pack_header",
+ ],
+ shared_libs: [
+ "libcutils",
+ "liblog",
+ "libOpenglCodecCommon",
+ ],
+ static_libs: [
+ "libarect",
+ "libdrm",
+ "libandroidemu_static",
+ "libGoldfishAddressSpace",
+ "libgfxstream_guest_gralloc",
+ "libmesa_vulkan_util_gfxstream",
+ "libmesa_vulkan_runtime_gfxstream",
+ "libgfxstream_guest_vulkan_entrypoints",
+ "libmesa_util_gfxstream",
+ "libmesa_util_format_gfxstream",
+ "libmesa_util_c11_gfxstream",
+ ],
+ cflags: [
+ "-DLOG_TAG=\"goldfish_vulkan\"",
+ "-DVIRTIO_GPU",
+ "-DVK_ANDROID_native_buffer",
+ "-DVK_EXT_device_memory_report",
+ "-DVK_GOOGLE_gfxstream",
+ "-DVK_NO_PROTOTYPES",
+ "-DVK_USE_PLATFORM_ANDROID_KHR",
+ "-fstrict-aliasing",
+ "-Werror",
+ "-Wno-missing-field-initializers",
+ "-Wno-unused-parameter",
+ "-DHAVE_PTHREAD=1",
+ "-DHAVE_TIMESPEC_GET",
+ "-DHAVE_STRUCT_TIMESPEC",
+ ],
+ srcs: [
+ ":vulkan_enc_impl",
],
export_include_dirs: [
".",
],
+ ldflags: [
+ // Mesa always adds Bsymbolic when available (see 'ld_args_bsymbolic' in Meson build). Duplicate that
+ // behavior here. '--gc-sections' has stronger justification: this lets drivers drop
+ // shared code unused by that specific driver (particularly relevant for Vulkan drivers).
+ "-Wl,-Bsymbolic",
+ "-Wl,--gc-sections",
+ ],
target: {
android: {
shared_libs: [
@@ -89,11 +178,11 @@
header_libs: [
"hwvulkan_headers",
],
- }
- }
+ },
+ },
}
-cc_library_shared {
+cc_library_static {
name: "libvulkan_enc",
defaults: [
"libgfxstream_guest_vulkan_encoder_defaults",
@@ -103,16 +192,14 @@
],
}
-cc_library_shared {
+cc_library_static {
name: "libgfxstream_guest_vulkan_encoder_with_host",
defaults: [
"libgfxstream_guest_vulkan_encoder_defaults",
],
shared_libs: [
- "libgfxstream_backend",
- ],
- static_libs: [
"libplatform_rutabaga",
+ "libgfxstream_backend",
],
target: {
host: {
diff --git a/guest/vulkan_enc/AndroidHardwareBuffer.cpp b/guest/vulkan_enc/AndroidHardwareBuffer.cpp
index 3f0c34a..eac0caf 100644
--- a/guest/vulkan_enc/AndroidHardwareBuffer.cpp
+++ b/guest/vulkan_enc/AndroidHardwareBuffer.cpp
@@ -21,11 +21,11 @@
#endif
#endif
-#include "../OpenglSystemCommon/HostConnection.h"
+#include <assert.h>
+#include "../OpenglSystemCommon/HostConnection.h"
#include "vk_format_info.h"
#include "vk_util.h"
-#include <assert.h>
namespace gfxstream {
namespace vk {
@@ -34,36 +34,28 @@
/* Construct ahw usage mask from image usage bits, see
* 'AHardwareBuffer Usage Equivalence' in Vulkan spec.
*/
-uint64_t
-getAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags vk_create,
- const VkImageUsageFlags vk_usage)
-{
- uint64_t ahw_usage = 0;
+uint64_t getAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags vk_create,
+ const VkImageUsageFlags vk_usage) {
+ uint64_t ahw_usage = 0;
- if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT)
- ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+ if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT) ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
- if (vk_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
- ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+ if (vk_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
+ ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
- if (vk_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
- ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
+ if (vk_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
+ ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
- if (vk_create & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
- ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
+ if (vk_create & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
+ ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
- if (vk_create & VK_IMAGE_CREATE_PROTECTED_BIT)
- ahw_usage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
+ if (vk_create & VK_IMAGE_CREATE_PROTECTED_BIT)
+ ahw_usage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
- /* No usage bits set - set at least one GPU usage. */
- if (ahw_usage == 0)
- ahw_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+ /* No usage bits set - set at least one GPU usage. */
+ if (ahw_usage == 0) ahw_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
- return ahw_usage;
-}
-
-void updateMemoryTypeBits(uint32_t* memoryTypeBits, uint32_t colorBufferMemoryIndex) {
- *memoryTypeBits = 1u << colorBufferMemoryIndex;
+ return ahw_usage;
}
VkResult getAndroidHardwareBufferPropertiesANDROID(
@@ -74,45 +66,45 @@
const auto format = grallocHelper->getFormat(buffer);
if (ahbFormatProps) {
- switch(format) {
+ switch (format) {
case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
- ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
- break;
+ ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
+ break;
case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
- ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
- break;
+ ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
+ break;
case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
- ahbFormatProps->format = VK_FORMAT_R8G8B8_UNORM;
- break;
+ ahbFormatProps->format = VK_FORMAT_R8G8B8_UNORM;
+ break;
case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
- ahbFormatProps->format = VK_FORMAT_R5G6B5_UNORM_PACK16;
- break;
+ ahbFormatProps->format = VK_FORMAT_R5G6B5_UNORM_PACK16;
+ break;
case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
- ahbFormatProps->format = VK_FORMAT_R16G16B16A16_SFLOAT;
- break;
+ ahbFormatProps->format = VK_FORMAT_R16G16B16A16_SFLOAT;
+ break;
case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
- ahbFormatProps->format = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
- break;
+ ahbFormatProps->format = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+ break;
case AHARDWAREBUFFER_FORMAT_D16_UNORM:
- ahbFormatProps->format = VK_FORMAT_D16_UNORM;
- break;
+ ahbFormatProps->format = VK_FORMAT_D16_UNORM;
+ break;
case AHARDWAREBUFFER_FORMAT_D24_UNORM:
- ahbFormatProps->format = VK_FORMAT_X8_D24_UNORM_PACK32;
- break;
+ ahbFormatProps->format = VK_FORMAT_X8_D24_UNORM_PACK32;
+ break;
case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
- ahbFormatProps->format = VK_FORMAT_D24_UNORM_S8_UINT;
- break;
+ ahbFormatProps->format = VK_FORMAT_D24_UNORM_S8_UINT;
+ break;
case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
- ahbFormatProps->format = VK_FORMAT_D32_SFLOAT;
- break;
+ ahbFormatProps->format = VK_FORMAT_D32_SFLOAT;
+ break;
case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
- ahbFormatProps->format = VK_FORMAT_D32_SFLOAT_S8_UINT;
- break;
+ ahbFormatProps->format = VK_FORMAT_D32_SFLOAT_S8_UINT;
+ break;
case AHARDWAREBUFFER_FORMAT_S8_UINT:
- ahbFormatProps->format = VK_FORMAT_S8_UINT;
- break;
+ ahbFormatProps->format = VK_FORMAT_S8_UINT;
+ break;
default:
- ahbFormatProps->format = VK_FORMAT_UNDEFINED;
+ ahbFormatProps->format = VK_FORMAT_UNDEFINED;
}
ahbFormatProps->externalFormat = format;
@@ -128,10 +120,8 @@
// VK_FORMAT_FEATURE_TRANSFER_DST_BIT
// VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
ahbFormatProps->formatFeatures =
- VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
- VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT |
- VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
- VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT |
+ VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
// "Implementations may not always be able to determine the color model,
@@ -166,7 +156,8 @@
// * U (CB) comes from the B-channel (after swizzle)
// * V (CR) comes from the R-channel (after swizzle)
//
- // See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#textures-sampler-YCbCr-conversion
+ // See
+ // https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#textures-sampler-YCbCr-conversion
//
// To match the above, the guest needs to swizzle such that:
//
@@ -204,10 +195,9 @@
#endif
#endif
- ahbFormatProps->suggestedYcbcrModel =
- android_format_is_yuv(format) ?
- VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 :
- VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+ ahbFormatProps->suggestedYcbcrModel = android_format_is_yuv(format)
+ ? VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601
+ : VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
ahbFormatProps->suggestedYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
ahbFormatProps->suggestedXChromaOffset = VK_CHROMA_LOCATION_MIDPOINT;
@@ -281,26 +271,24 @@
/* If caller passed dedicated information. */
if (hasDedicatedImage) {
- w = imageExtent.width;
- h = imageExtent.height;
- layers = imageLayers;
- format = android_format_from_vk(imageFormat);
- usage = getAndroidHardwareBufferUsageFromVkUsage(imageCreateFlags, imageUsage);
+ w = imageExtent.width;
+ h = imageExtent.height;
+ layers = imageLayers;
+ format = android_format_from_vk(imageFormat);
+ usage = getAndroidHardwareBufferUsageFromVkUsage(imageCreateFlags, imageUsage);
} else if (hasDedicatedBuffer) {
- w = bufferSize;
- format = AHARDWAREBUFFER_FORMAT_BLOB;
- usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
- AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
- AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
+ w = bufferSize;
+ format = AHARDWAREBUFFER_FORMAT_BLOB;
+ usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+ AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
} else {
- w = allocationInfoAllocSize;
- format = AHARDWAREBUFFER_FORMAT_BLOB;
- usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
- AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
- AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
+ w = allocationInfoAllocSize;
+ format = AHARDWAREBUFFER_FORMAT_BLOB;
+ usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+ AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
}
- struct AHardwareBuffer *ahb = NULL;
+ struct AHardwareBuffer* ahb = NULL;
if (gralloc->allocate(w, h, format, usage, &ahb) != 0) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/guest/vulkan_enc/AndroidHardwareBuffer.h b/guest/vulkan_enc/AndroidHardwareBuffer.h
index b4085b6..0389f09 100644
--- a/guest/vulkan_enc/AndroidHardwareBuffer.h
+++ b/guest/vulkan_enc/AndroidHardwareBuffer.h
@@ -25,10 +25,8 @@
namespace gfxstream {
namespace vk {
-uint64_t
-getAndroidHardwareBufferUsageFromVkUsage(
- const VkImageCreateFlags vk_create,
- const VkImageUsageFlags vk_usage);
+uint64_t getAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags vk_create,
+ const VkImageUsageFlags vk_usage);
void updateMemoryTypeBits(uint32_t* memoryTypeBits, uint32_t colorBufferMemoryIndex);
diff --git a/guest/vulkan_enc/CommandBufferStagingStream.cpp b/guest/vulkan_enc/CommandBufferStagingStream.cpp
index 1f57387..63db2fa 100644
--- a/guest/vulkan_enc/CommandBufferStagingStream.cpp
+++ b/guest/vulkan_enc/CommandBufferStagingStream.cpp
@@ -1,18 +1,18 @@
/*
-* Copyright (C) 2021 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
#include "CommandBufferStagingStream.h"
#if PLATFORM_SDK_VERSION < 26
@@ -204,37 +204,33 @@
return (void*)(getDataPtr() + m_writePos);
}
-int CommandBufferStagingStream::commitBuffer(size_t size)
-{
+int CommandBufferStagingStream::commitBuffer(size_t size) {
m_writePos += size;
return 0;
}
-const unsigned char *CommandBufferStagingStream::readFully(void*, size_t) {
+const unsigned char* CommandBufferStagingStream::readFully(void*, size_t) {
// Not supported
ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
abort();
return nullptr;
}
-const unsigned char *CommandBufferStagingStream::read(void*, size_t*) {
+const unsigned char* CommandBufferStagingStream::read(void*, size_t*) {
// Not supported
ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
abort();
return nullptr;
}
-int CommandBufferStagingStream::writeFully(const void*, size_t)
-{
+int CommandBufferStagingStream::writeFully(const void*, size_t) {
// Not supported
ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
abort();
return 0;
}
-const unsigned char *CommandBufferStagingStream::commitBufferAndReadFully(
- size_t, void *, size_t) {
-
+const unsigned char* CommandBufferStagingStream::commitBufferAndReadFully(size_t, void*, size_t) {
// Not supported
ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
abort();
diff --git a/guest/vulkan_enc/CommandBufferStagingStream.h b/guest/vulkan_enc/CommandBufferStagingStream.h
index 8e754b7..45af8dc 100644
--- a/guest/vulkan_enc/CommandBufferStagingStream.h
+++ b/guest/vulkan_enc/CommandBufferStagingStream.h
@@ -1,18 +1,18 @@
/*
-* Copyright (C) 2021 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
#ifndef __COMMAND_BUFFER_STAGING_STREAM_H
#define __COMMAND_BUFFER_STAGING_STREAM_H
@@ -26,91 +26,91 @@
namespace vk {
class CommandBufferStagingStream : public gfxstream::guest::IOStream {
-public:
- // host will write kSyncDataReadComplete to the sync bytes to indicate memory is no longer being
- // used by host. This is only used with custom allocators. The sync bytes are used to ensure that,
- // during reallocations the guest does not free memory being read by the host. The guest ensures
- // that the sync bytes are marked as read complete before releasing the memory.
- static constexpr size_t kSyncDataSize = 8;
- // indicates read is complete
- static constexpr uint32_t kSyncDataReadComplete = 0X0;
- // indicates read is pending
- static constexpr uint32_t kSyncDataReadPending = 0X1;
+ public:
+ // host will write kSyncDataReadComplete to the sync bytes to indicate memory is no longer being
+ // used by host. This is only used with custom allocators. The sync bytes are used to ensure
+ // that, during reallocations the guest does not free memory being read by the host. The guest
+ // ensures that the sync bytes are marked as read complete before releasing the memory.
+ static constexpr size_t kSyncDataSize = 8;
+ // indicates read is complete
+ static constexpr uint32_t kSyncDataReadComplete = 0X0;
+ // indicates read is pending
+ static constexpr uint32_t kSyncDataReadPending = 0X1;
- // \struct backing memory structure
- struct Memory {
- VkDeviceMemory deviceMemory =
- VK_NULL_HANDLE; // device memory associated with allocated memory
- void* ptr = nullptr; // pointer to allocated memory
- bool operator==(const Memory& rhs) const {
- return (deviceMemory == rhs.deviceMemory) && (ptr == rhs.ptr);
- }
- };
+ // \struct backing memory structure
+ struct Memory {
+ VkDeviceMemory deviceMemory =
+ VK_NULL_HANDLE; // device memory associated with allocated memory
+ void* ptr = nullptr; // pointer to allocated memory
+ bool operator==(const Memory& rhs) const {
+ return (deviceMemory == rhs.deviceMemory) && (ptr == rhs.ptr);
+ }
+ };
- // allocator
- // param size to allocate
- // return allocated memory
- using Alloc = std::function<Memory(size_t)>;
- // free function
- // param memory to free
- using Free = std::function<void(const Memory&)>;
- // constructor
- // \param allocFn is the allocation function provided.
- // \param freeFn is the free function provided
- explicit CommandBufferStagingStream(const Alloc& allocFn, const Free& freeFn);
- // constructor
- explicit CommandBufferStagingStream();
- ~CommandBufferStagingStream();
+ // allocator
+ // param size to allocate
+ // return allocated memory
+ using Alloc = std::function<Memory(size_t)>;
+ // free function
+ // param memory to free
+ using Free = std::function<void(const Memory&)>;
+ // constructor
+ // \param allocFn is the allocation function provided.
+ // \param freeFn is the free function provided
+ explicit CommandBufferStagingStream(const Alloc& allocFn, const Free& freeFn);
+ // constructor
+ explicit CommandBufferStagingStream();
+ ~CommandBufferStagingStream();
- virtual size_t idealAllocSize(size_t len);
- virtual void* allocBuffer(size_t minSize);
- virtual int commitBuffer(size_t size);
- virtual const unsigned char* readFully(void* buf, size_t len);
- virtual const unsigned char* read(void* buf, size_t* inout_len);
- virtual int writeFully(const void* buf, size_t len);
- virtual const unsigned char* commitBufferAndReadFully(size_t size, void* buf, size_t len);
+ virtual size_t idealAllocSize(size_t len);
+ virtual void* allocBuffer(size_t minSize);
+ virtual int commitBuffer(size_t size);
+ virtual const unsigned char* readFully(void* buf, size_t len);
+ virtual const unsigned char* read(void* buf, size_t* inout_len);
+ virtual int writeFully(const void* buf, size_t len);
+ virtual const unsigned char* commitBufferAndReadFully(size_t size, void* buf, size_t len);
- void getWritten(unsigned char** bufOut, size_t* sizeOut);
- void reset();
+ void getWritten(unsigned char** bufOut, size_t* sizeOut);
+ void reset();
- // marks the command buffer stream as flushing. The owner of CommandBufferStagingStream
- // should call markFlushing after finishing writing to the stream.
- // This will mark the sync data to kSyncDataReadPending. This is only applicable when
- // using custom allocators. markFlushing will be a no-op if called
- // when not using custom allocators
- void markFlushing();
+ // marks the command buffer stream as flushing. The owner of CommandBufferStagingStream
+ // should call markFlushing after finishing writing to the stream.
+ // This will mark the sync data to kSyncDataReadPending. This is only applicable when
+ // using custom allocators. markFlushing will be a no-op if called
+ // when not using custom allocators
+ void markFlushing();
- // gets the device memory associated with the stream. This is VK_NULL_HANDLE for default allocation
- // \return device memory
- VkDeviceMemory getDeviceMemory();
+ // gets the device memory associated with the stream. This is VK_NULL_HANDLE for default
+ // allocation \return device memory
+ VkDeviceMemory getDeviceMemory();
-private:
- // underlying memory for data
- Memory m_mem;
- // size of portion of memory available for data.
- // for custom allocation, this size excludes size of sync data.
- size_t m_size;
- // current write position in data buffer
- uint32_t m_writePos;
+ private:
+ // underlying memory for data
+ Memory m_mem;
+ // size of portion of memory available for data.
+ // for custom allocation, this size excludes size of sync data.
+ size_t m_size;
+ // current write position in data buffer
+ uint32_t m_writePos;
- // alloc function
- Alloc m_alloc;
- // free function
- Free m_free;
+ // alloc function
+ Alloc m_alloc;
+ // free function
+ Free m_free;
- // realloc function
- // \param size of memory to be allocated
- // \ param reference size to update with actual size allocated. This size can be < requested size
- // for custom allocation to account for sync data
- using Realloc = std::function<Memory(const Memory&, size_t)>;
- Realloc m_realloc;
+ // realloc function
+ // \param size of memory to be allocated
+ // \ param reference size to update with actual size allocated. This size can be < requested
+ // size for custom allocation to account for sync data
+ using Realloc = std::function<Memory(const Memory&, size_t)>;
+ Realloc m_realloc;
- // flag tracking use of custom allocation/free
- bool m_usingCustomAlloc = false;
+ // flag tracking use of custom allocation/free
+ bool m_usingCustomAlloc = false;
- // adjusted memory location to point to start of data after accounting for metadata
- // \return pointer to data start
- unsigned char* getDataPtr();
+ // adjusted memory location to point to start of data after accounting for metadata
+ // \return pointer to data start
+ unsigned char* getDataPtr();
};
} // namespace vk
diff --git a/guest/vulkan_enc/DescriptorSetVirtualization.cpp b/guest/vulkan_enc/DescriptorSetVirtualization.cpp
index fa0cb78..d2389a4 100644
--- a/guest/vulkan_enc/DescriptorSetVirtualization.cpp
+++ b/guest/vulkan_enc/DescriptorSetVirtualization.cpp
@@ -13,6 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "DescriptorSetVirtualization.h"
+
#include "Resources.h"
namespace gfxstream {
@@ -27,7 +28,8 @@
set->pendingWriteArrayRanges.clear();
}
-void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings, DescriptorWriteTable& table) {
+void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings,
+ DescriptorWriteTable& table) {
uint32_t highestBindingNumber = 0;
for (uint32_t i = 0; i < layoutBindings.size(); ++i) {
@@ -39,8 +41,7 @@
std::vector<uint32_t> countsEachBinding(highestBindingNumber + 1, 0);
for (uint32_t i = 0; i < layoutBindings.size(); ++i) {
- countsEachBinding[layoutBindings[i].binding] =
- layoutBindings[i].descriptorCount;
+ countsEachBinding[layoutBindings[i].binding] = layoutBindings[i].descriptorCount;
}
table.resize(countsEachBinding.size());
@@ -55,8 +56,8 @@
}
}
-static void initializeReifiedDescriptorSet(VkDescriptorPool pool, VkDescriptorSetLayout setLayout, ReifiedDescriptorSet* set) {
-
+static void initializeReifiedDescriptorSet(VkDescriptorPool pool, VkDescriptorSetLayout setLayout,
+ ReifiedDescriptorSet* set) {
set->pendingWriteArrayRanges.clear();
const auto& layoutInfo = *(as_goldfish_VkDescriptorSetLayout(setLayout)->layoutInfo);
@@ -73,8 +74,7 @@
set->bindingIsImmutableSampler[bindingIndex] =
binding.descriptorCount > 0 &&
(binding.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
- binding.descriptorType ==
- VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) &&
+ binding.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) &&
binding.pImmutableSamplers;
}
@@ -185,7 +185,8 @@
}
}
-void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src, ReifiedDescriptorSet* dst) {
+void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src,
+ ReifiedDescriptorSet* dst) {
const DescriptorWriteTable& srcTable = src->allWrites;
DescriptorWriteTable& dstTable = dst->allWrites;
@@ -214,14 +215,10 @@
}
}
-void doEmulatedDescriptorImageInfoWriteFromTemplate(
- VkDescriptorType descType,
- uint32_t binding,
- uint32_t dstArrayElement,
- uint32_t count,
- const VkDescriptorImageInfo* imageInfos,
- ReifiedDescriptorSet* set) {
-
+void doEmulatedDescriptorImageInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+ uint32_t dstArrayElement, uint32_t count,
+ const VkDescriptorImageInfo* imageInfos,
+ ReifiedDescriptorSet* set) {
DescriptorWriteTable& table = set->allWrites;
uint32_t currBinding = binding;
@@ -239,14 +236,10 @@
}
}
-void doEmulatedDescriptorBufferInfoWriteFromTemplate(
- VkDescriptorType descType,
- uint32_t binding,
- uint32_t dstArrayElement,
- uint32_t count,
- const VkDescriptorBufferInfo* bufferInfos,
- ReifiedDescriptorSet* set) {
-
+void doEmulatedDescriptorBufferInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+ uint32_t dstArrayElement, uint32_t count,
+ const VkDescriptorBufferInfo* bufferInfos,
+ ReifiedDescriptorSet* set) {
DescriptorWriteTable& table = set->allWrites;
uint32_t currBinding = binding;
@@ -264,14 +257,10 @@
}
}
-void doEmulatedDescriptorBufferViewWriteFromTemplate(
- VkDescriptorType descType,
- uint32_t binding,
- uint32_t dstArrayElement,
- uint32_t count,
- const VkBufferView* bufferViews,
- ReifiedDescriptorSet* set) {
-
+void doEmulatedDescriptorBufferViewWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+ uint32_t dstArrayElement, uint32_t count,
+ const VkBufferView* bufferViews,
+ ReifiedDescriptorSet* set) {
DescriptorWriteTable& table = set->allWrites;
uint32_t currBinding = binding;
@@ -305,22 +294,19 @@
static bool isBindingFeasibleForAlloc(
const DescriptorPoolAllocationInfo::DescriptorCountInfo& countInfo,
const VkDescriptorSetLayoutBinding& binding) {
-
if (binding.descriptorCount && (countInfo.type != binding.descriptorType)) {
return false;
}
- uint32_t availDescriptorCount =
- countInfo.descriptorCount - countInfo.used;
+ uint32_t availDescriptorCount = countInfo.descriptorCount - countInfo.used;
if (availDescriptorCount < binding.descriptorCount) {
- ALOGV("%s: Ran out of descriptors of type 0x%x. "
- "Wanted %u from layout but "
- "we only have %u free (total in pool: %u)\n", __func__,
- binding.descriptorType,
- binding.descriptorCount,
- countInfo.descriptorCount - countInfo.used,
- countInfo.descriptorCount);
+ ALOGV(
+ "%s: Ran out of descriptors of type 0x%x. "
+ "Wanted %u from layout but "
+ "we only have %u free (total in pool: %u)\n",
+ __func__, binding.descriptorType, binding.descriptorCount,
+ countInfo.descriptorCount - countInfo.used, countInfo.descriptorCount);
return false;
}
@@ -330,31 +316,27 @@
static bool isBindingFeasibleForFree(
const DescriptorPoolAllocationInfo::DescriptorCountInfo& countInfo,
const VkDescriptorSetLayoutBinding& binding) {
-
if (countInfo.type != binding.descriptorType) return false;
if (countInfo.used < binding.descriptorCount) {
- ALOGV("%s: Was a descriptor set double freed? "
- "Ran out of descriptors of type 0x%x. "
- "Wanted to free %u from layout but "
- "we only have %u used (total in pool: %u)\n", __func__,
- binding.descriptorType,
- binding.descriptorCount,
- countInfo.used,
- countInfo.descriptorCount);
+ ALOGV(
+ "%s: Was a descriptor set double freed? "
+ "Ran out of descriptors of type 0x%x. "
+ "Wanted to free %u from layout but "
+ "we only have %u used (total in pool: %u)\n",
+ __func__, binding.descriptorType, binding.descriptorCount, countInfo.used,
+ countInfo.descriptorCount);
return false;
}
return true;
}
-static void allocBindingFeasible(
- const VkDescriptorSetLayoutBinding& binding,
- DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
+static void allocBindingFeasible(const VkDescriptorSetLayoutBinding& binding,
+ DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
poolState.used += binding.descriptorCount;
}
-static void freeBindingFeasible(
- const VkDescriptorSetLayoutBinding& binding,
- DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
+static void freeBindingFeasible(const VkDescriptorSetLayoutBinding& binding,
+ DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
poolState.used -= binding.descriptorCount;
}
@@ -366,11 +348,11 @@
auto setsAvailable = poolInfo->maxSets - poolInfo->usedSets;
if (setsAvailable < pAllocateInfo->descriptorSetCount) {
- ALOGV("%s: Error: VkDescriptorSetAllocateInfo wants %u sets "
- "but we only have %u available. "
- "Bailing with VK_ERROR_OUT_OF_POOL_MEMORY.\n", __func__,
- pAllocateInfo->descriptorSetCount,
- setsAvailable);
+ ALOGV(
+ "%s: Error: VkDescriptorSetAllocateInfo wants %u sets "
+ "but we only have %u available. "
+ "Bailing with VK_ERROR_OUT_OF_POOL_MEMORY.\n",
+ __func__, pAllocateInfo->descriptorSetCount, setsAvailable);
return VK_ERROR_OUT_OF_POOL_MEMORY;
}
@@ -381,11 +363,13 @@
for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) {
if (!pAllocateInfo->pSetLayouts[i]) {
- ALOGV("%s: Error: Tried to allocate a descriptor set with null set layout.\n", __func__);
+ ALOGV("%s: Error: Tried to allocate a descriptor set with null set layout.\n",
+ __func__);
return VK_ERROR_INITIALIZATION_FAILED;
}
- auto setLayoutInfo = as_goldfish_VkDescriptorSetLayout(pAllocateInfo->pSetLayouts[i])->layoutInfo;
+ auto setLayoutInfo =
+ as_goldfish_VkDescriptorSetLayout(pAllocateInfo->pSetLayouts[i])->layoutInfo;
if (!setLayoutInfo) {
return VK_ERROR_INITIALIZATION_FAILED;
}
@@ -423,7 +407,8 @@
}
}
-void removeDescriptorSetAllocation(VkDescriptorPool pool, const std::vector<VkDescriptorSetLayoutBinding>& bindings) {
+void removeDescriptorSetAllocation(VkDescriptorPool pool,
+ const std::vector<VkDescriptorSetLayoutBinding>& bindings) {
auto allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
if (0 == allocInfo->usedSets) {
@@ -442,7 +427,8 @@
}
}
-void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout, VkDescriptorSet set) {
+void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout,
+ VkDescriptorSet set) {
DescriptorPoolAllocationInfo* allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
ReifiedDescriptorSet* newReified = new ReifiedDescriptorSet;
@@ -457,7 +443,8 @@
initializeReifiedDescriptorSet(pool, setLayout, newReified);
}
-VkResult validateAndApplyVirtualDescriptorSetAllocation(const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets) {
+VkResult validateAndApplyVirtualDescriptorSetAllocation(
+ const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets) {
VkResult validateRes = validateDescriptorSetAllocation(pAllocateInfo);
if (validateRes != VK_SUCCESS) return validateRes;
@@ -470,15 +457,15 @@
DescriptorPoolAllocationInfo* allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
if (allocInfo->freePoolIds.size() < pAllocateInfo->descriptorSetCount) {
- ALOGE("%s: FATAL: Somehow out of descriptor pool IDs. Wanted %u IDs but only have %u free IDs remaining. The count for maxSets was %u and used was %u\n", __func__,
- pAllocateInfo->descriptorSetCount,
- (uint32_t)allocInfo->freePoolIds.size(),
- allocInfo->maxSets,
- allocInfo->usedSets);
+ ALOGE(
+ "%s: FATAL: Somehow out of descriptor pool IDs. Wanted %u IDs but only have %u free "
+ "IDs remaining. The count for maxSets was %u and used was %u\n",
+ __func__, pAllocateInfo->descriptorSetCount, (uint32_t)allocInfo->freePoolIds.size(),
+ allocInfo->maxSets, allocInfo->usedSets);
abort();
}
- for (uint32_t i = 0 ; i < pAllocateInfo->descriptorSetCount; ++i) {
+ for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) {
uint64_t id = allocInfo->freePoolIds.back();
allocInfo->freePoolIds.pop_back();
@@ -498,7 +485,8 @@
DescriptorPoolAllocationInfo* allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
if (usePoolIds) {
- // Look for the set's pool Id in the pool. If not found, then this wasn't really allocated, and bail.
+ // Look for the set's pool Id in the pool. If not found, then this wasn't really allocated,
+ // and bail.
if (allocInfo->allocedPoolIds.find(reified->poolId) == allocInfo->allocedPoolIds.end()) {
return false;
}
@@ -522,7 +510,7 @@
toClear.push_back(set);
}
- for (auto set: toClear) {
+ for (auto set : toClear) {
removeDescriptorSetFromPool(set, usePoolIds);
}
diff --git a/guest/vulkan_enc/DescriptorSetVirtualization.h b/guest/vulkan_enc/DescriptorSetVirtualization.h
index c6a6c42..0491102 100644
--- a/guest/vulkan_enc/DescriptorSetVirtualization.h
+++ b/guest/vulkan_enc/DescriptorSetVirtualization.h
@@ -14,13 +14,13 @@
// limitations under the License.
#pragma once
-#include "aemu/base/containers/EntityManager.h"
-
#include <vulkan/vulkan.h>
#include <unordered_set>
#include <vector>
+#include "aemu/base/containers/EntityManager.h"
+
namespace gfxstream {
namespace vk {
@@ -37,7 +37,7 @@
DescriptorWriteType type;
VkDescriptorType descriptorType;
- uint32_t dstArrayElement; // Only used for inlineUniformBlock and accelerationStructure.
+ uint32_t dstArrayElement; // Only used for inlineUniformBlock and accelerationStructure.
union {
VkDescriptorImageInfo imageInfo;
@@ -105,7 +105,8 @@
void clearReifiedDescriptorSet(ReifiedDescriptorSet* set);
-void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings, DescriptorWriteTable& table);
+void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings,
+ DescriptorWriteTable& table);
bool isDescriptorTypeImageInfo(VkDescriptorType descType);
bool isDescriptorTypeBufferInfo(VkDescriptorType descType);
@@ -114,31 +115,23 @@
bool isDescriptorTypeAccelerationStructure(VkDescriptorType descType);
void doEmulatedDescriptorWrite(const VkWriteDescriptorSet* write, ReifiedDescriptorSet* toWrite);
-void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src, ReifiedDescriptorSet* dst);
+void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src,
+ ReifiedDescriptorSet* dst);
-void doEmulatedDescriptorImageInfoWriteFromTemplate(
- VkDescriptorType descType,
- uint32_t binding,
- uint32_t dstArrayElement,
- uint32_t count,
- const VkDescriptorImageInfo* imageInfos,
- ReifiedDescriptorSet* set);
+void doEmulatedDescriptorImageInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+ uint32_t dstArrayElement, uint32_t count,
+ const VkDescriptorImageInfo* imageInfos,
+ ReifiedDescriptorSet* set);
-void doEmulatedDescriptorBufferInfoWriteFromTemplate(
- VkDescriptorType descType,
- uint32_t binding,
- uint32_t dstArrayElement,
- uint32_t count,
- const VkDescriptorBufferInfo* bufferInfos,
- ReifiedDescriptorSet* set);
+void doEmulatedDescriptorBufferInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+ uint32_t dstArrayElement, uint32_t count,
+ const VkDescriptorBufferInfo* bufferInfos,
+ ReifiedDescriptorSet* set);
-void doEmulatedDescriptorBufferViewWriteFromTemplate(
- VkDescriptorType descType,
- uint32_t binding,
- uint32_t dstArrayElement,
- uint32_t count,
- const VkBufferView* bufferViews,
- ReifiedDescriptorSet* set);
+void doEmulatedDescriptorBufferViewWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+ uint32_t dstArrayElement, uint32_t count,
+ const VkBufferView* bufferViews,
+ ReifiedDescriptorSet* set);
void doEmulatedDescriptorInlineUniformBlockFromTemplate(VkDescriptorType descType, uint32_t binding,
uint32_t dstArrayElement, uint32_t count,
@@ -146,8 +139,10 @@
ReifiedDescriptorSet* set);
void applyDescriptorSetAllocation(VkDescriptorPool pool, VkDescriptorSetLayout setLayout);
-void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout, VkDescriptorSet set);
-VkResult validateAndApplyVirtualDescriptorSetAllocation(const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets);
+void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout,
+ VkDescriptorSet set);
+VkResult validateAndApplyVirtualDescriptorSetAllocation(
+ const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets);
// Returns false if set wasn't found in its pool.
bool removeDescriptorSetFromPool(VkDescriptorSet set, bool usePoolIds);
diff --git a/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp b/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
index 3f2f75c..dcf9f65 100644
--- a/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
+++ b/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
@@ -45,10 +45,9 @@
VkDevice device, VkDeviceMemory memory)
: mSize(size), mBlock(block), mDevice(device), mMemory(memory) {
void* address = block->mmap(gpuAddr);
- mAllocator =
- std::make_unique<gfxstream::guest::SubAllocator>(address, mSize, kLargestPageSize);
+ mAllocator = std::make_unique<gfxstream::guest::SubAllocator>(address, mSize, kLargestPageSize);
}
-#endif // defined(__ANDROID__)
+#endif // defined(__ANDROID__)
CoherentMemory::~CoherentMemory() {
ResourceTracker::getThreadLocalEncoder()->vkFreeMemorySyncGOOGLE(mDevice, mMemory, nullptr,
diff --git a/guest/vulkan_enc/HostVisibleMemoryVirtualization.h b/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
index 051ea69..92acd5e 100644
--- a/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
+++ b/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
@@ -47,7 +47,7 @@
#if defined(__ANDROID__)
CoherentMemory(GoldfishAddressSpaceBlockPtr block, uint64_t gpuAddr, uint64_t size,
VkDevice device, VkDeviceMemory memory);
-#endif // defined(__ANDROID__)
+#endif // defined(__ANDROID__)
~CoherentMemory();
diff --git a/guest/vulkan_enc/ResourceTracker.cpp b/guest/vulkan_enc/ResourceTracker.cpp
index 4e4d0e7..202090a 100644
--- a/guest/vulkan_enc/ResourceTracker.cpp
+++ b/guest/vulkan_enc/ResourceTracker.cpp
@@ -23,6 +23,7 @@
#include "Resources.h"
#include "VkEncoder.h"
#include "aemu/base/AlignedBuf.h"
+#include "gfxstream_vk_private.h"
#include "goldfish_address_space.h"
#include "goldfish_vk_private_defs.h"
#include "util.h"
@@ -200,10 +201,10 @@
std::unordered_set<VkDescriptorSet> sets;
};
-#define HANDLE_REGISTER_IMPL_IMPL(type) \
- void ResourceTracker::register_##type(type obj) { \
- AutoLock<RecursiveLock> lock(mLock); \
- info_##type[obj] = type##_Info(); \
+#define HANDLE_REGISTER_IMPL_IMPL(type) \
+ void ResourceTracker::register_##type(type obj) { \
+ AutoLock<RecursiveLock> lock(mLock); \
+ info_##type[obj] = type##_Info(); \
}
#define HANDLE_UNREGISTER_IMPL_IMPL(type) \
@@ -286,7 +287,8 @@
return as_goldfish_VkDescriptorSet(dstSet)->reified->bindingIsImmutableSampler[dstBinding];
}
-VkDescriptorImageInfo ResourceTracker::filterNonexistentSampler(const VkDescriptorImageInfo& inputInfo) {
+VkDescriptorImageInfo ResourceTracker::filterNonexistentSampler(
+ const VkDescriptorImageInfo& inputInfo) {
VkSampler sampler = inputInfo.sampler;
VkDescriptorImageInfo res = inputInfo;
@@ -300,9 +302,11 @@
return res;
}
-void ResourceTracker::emitDeviceMemoryReport(VkDevice_Info info, VkDeviceMemoryReportEventTypeEXT type,
- uint64_t memoryObjectId, VkDeviceSize size, VkObjectType objectType,
- uint64_t objectHandle, uint32_t heapIndex) {
+void ResourceTracker::emitDeviceMemoryReport(VkDevice_Info info,
+ VkDeviceMemoryReportEventTypeEXT type,
+ uint64_t memoryObjectId, VkDeviceSize size,
+ VkObjectType objectType, uint64_t objectHandle,
+ uint32_t heapIndex) {
if (info.deviceMemoryReportCallbacks.empty()) return;
const VkDeviceMemoryReportCallbackDataEXT callbackData = {
@@ -640,9 +644,10 @@
createInfoDup.pNext = nullptr;
enc->vkGetLinearImageLayout2GOOGLE(device, &createInfoDup, &offset, &rowPitchAlignment,
true /* do lock */);
- ALOGD("vkGetLinearImageLayout2GOOGLE: format %d offset %lu "
- "rowPitchAlignment = %lu",
- (int)createInfo->format, offset, rowPitchAlignment);
+ ALOGD(
+ "vkGetLinearImageLayout2GOOGLE: format %d offset %lu "
+ "rowPitchAlignment = %lu",
+ (int)createInfo->format, offset, rowPitchAlignment);
}
imageConstraints.min_coded_width = createInfo->extent.width;
@@ -721,8 +726,8 @@
dedicatedReqs->requiresDedicatedAllocation = VK_TRUE;
}
-void ResourceTracker::setMemoryRequirementsForSysmemBackedImage(VkImage image,
- VkMemoryRequirements* pMemoryRequirements) {
+void ResourceTracker::transformImageMemoryRequirementsForGuestLocked(VkImage image,
+ VkMemoryRequirements* reqs) {
#ifdef VK_USE_PLATFORM_FUCHSIA
auto it = info_VkImage.find(image);
if (it == info_VkImage.end()) return;
@@ -730,21 +735,25 @@
if (info.isSysmemBackedMemory) {
auto width = info.createInfo.extent.width;
auto height = info.createInfo.extent.height;
- pMemoryRequirements->size = width * height * 4;
+ reqs->size = width * height * 4;
+ }
+#elif defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ auto it = info_VkImage.find(image);
+ if (it == info_VkImage.end()) return;
+ auto& info = it->second;
+ if (info.isWsiImage) {
+ static const uint32_t kColorBufferBpp = 4;
+ reqs->size = kColorBufferBpp * info.createInfo.extent.width * info.createInfo.extent.height;
}
#else
// Bypass "unused parameter" checks.
(void)image;
- (void)pMemoryRequirements;
+ (void)reqs;
#endif
}
-void ResourceTracker::transformImageMemoryRequirementsForGuestLocked(VkImage image,
- VkMemoryRequirements* reqs) {
- setMemoryRequirementsForSysmemBackedImage(image, reqs);
-}
-
-CoherentMemoryPtr ResourceTracker::freeCoherentMemoryLocked(VkDeviceMemory memory, VkDeviceMemory_Info& info) {
+CoherentMemoryPtr ResourceTracker::freeCoherentMemoryLocked(VkDeviceMemory memory,
+ VkDeviceMemory_Info& info) {
if (info.coherentMemory && info.ptr) {
if (info.coherentMemory->getDeviceMemory() != memory) {
delete_goldfish_VkDeviceMemory(memory);
@@ -1341,7 +1350,8 @@
void ResourceTracker::setDeviceMemoryInfo(VkDevice device, VkDeviceMemory memory,
VkDeviceSize allocationSize, uint8_t* ptr,
uint32_t memoryTypeIndex, AHardwareBuffer* ahw,
- bool imported, zx_handle_t vmoHandle) {
+ bool imported, zx_handle_t vmoHandle,
+ VirtGpuBlobPtr blobPtr) {
AutoLock<RecursiveLock> lock(mLock);
auto& info = info_VkDeviceMemory[memory];
@@ -1354,6 +1364,7 @@
#endif
info.imported = imported;
info.vmoHandle = vmoHandle;
+ info.blobPtr = blobPtr;
}
void ResourceTracker::setImageInfo(VkImage image, VkDevice device,
@@ -1763,6 +1774,7 @@
"VK_EXT_scalar_block_layout",
"VK_KHR_descriptor_update_template",
"VK_KHR_storage_buffer_storage_class",
+ "VK_EXT_depth_clip_enable",
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
"VK_KHR_external_semaphore",
"VK_KHR_external_semaphore_fd",
@@ -1772,7 +1784,7 @@
"VK_KHR_external_fence_fd",
"VK_EXT_device_memory_report",
#endif
-#if !defined(VK_USE_PLATFORM_ANDROID_KHR) && defined(__linux__)
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
"VK_KHR_create_renderpass2",
"VK_KHR_imageless_framebuffer",
#endif
@@ -1847,9 +1859,11 @@
bool win32ExtMemAvailable = getHostDeviceExtensionIndex("VK_KHR_external_memory_win32") != -1;
bool posixExtMemAvailable = getHostDeviceExtensionIndex("VK_KHR_external_memory_fd") != -1;
bool moltenVkExtAvailable = getHostDeviceExtensionIndex("VK_MVK_moltenvk") != -1;
+ bool qnxExtMemAvailable =
+ getHostDeviceExtensionIndex("VK_QNX_external_memory_screen_buffer") != -1;
bool hostHasExternalMemorySupport =
- win32ExtMemAvailable || posixExtMemAvailable || moltenVkExtAvailable;
+ win32ExtMemAvailable || posixExtMemAvailable || moltenVkExtAvailable || qnxExtMemAvailable;
if (hostHasExternalMemorySupport) {
#ifdef VK_USE_PLATFORM_ANDROID_KHR
@@ -2029,7 +2043,19 @@
}
void ResourceTracker::on_vkGetPhysicalDeviceProperties(void*, VkPhysicalDevice,
- VkPhysicalDeviceProperties*) {}
+ VkPhysicalDeviceProperties* pProperties) {
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ if (pProperties) {
+ if (VK_PHYSICAL_DEVICE_TYPE_CPU == pProperties->deviceType) {
+ /* For Linux guest: Even if host driver reports DEVICE_TYPE_CPU,
+ * override this to VIRTUAL_GPU, otherwise Linux DRM interfaces
+ * will take unexpected code paths to deal with "software" driver
+ */
+ pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
+ }
+ }
+#endif
+}
void ResourceTracker::on_vkGetPhysicalDeviceFeatures2(void*, VkPhysicalDevice,
VkPhysicalDeviceFeatures2* pFeatures) {
@@ -2048,7 +2074,8 @@
on_vkGetPhysicalDeviceFeatures2(context, physicalDevice, pFeatures);
}
-void ResourceTracker::on_vkGetPhysicalDeviceProperties2(void*, VkPhysicalDevice,
+void ResourceTracker::on_vkGetPhysicalDeviceProperties2(void* context,
+ VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties) {
if (pProperties) {
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* memoryReportFeaturesEXT =
@@ -2056,6 +2083,7 @@
if (memoryReportFeaturesEXT) {
memoryReportFeaturesEXT->deviceMemoryReport = VK_TRUE;
}
+ on_vkGetPhysicalDeviceProperties(context, physicalDevice, &pProperties->properties);
}
}
@@ -2142,6 +2170,12 @@
}
}
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
+void updateMemoryTypeBits(uint32_t* memoryTypeBits, uint32_t memoryIndex) {
+ *memoryTypeBits = 1u << memoryIndex;
+}
+#endif
+
#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkResult ResourceTracker::on_vkGetAndroidHardwareBufferPropertiesANDROID(
@@ -2843,6 +2877,33 @@
}
#endif
+static uint32_t getVirglFormat(VkFormat vkFormat) {
+ uint32_t virglFormat = 0;
+
+ switch (vkFormat) {
+ case VK_FORMAT_R8G8B8A8_SINT:
+ case VK_FORMAT_R8G8B8A8_UNORM:
+ case VK_FORMAT_R8G8B8A8_SRGB:
+ case VK_FORMAT_R8G8B8A8_SNORM:
+ case VK_FORMAT_R8G8B8A8_SSCALED:
+ case VK_FORMAT_R8G8B8A8_USCALED:
+ virglFormat = VIRGL_FORMAT_R8G8B8A8_UNORM;
+ break;
+ case VK_FORMAT_B8G8R8A8_SINT:
+ case VK_FORMAT_B8G8R8A8_UNORM:
+ case VK_FORMAT_B8G8R8A8_SRGB:
+ case VK_FORMAT_B8G8R8A8_SNORM:
+ case VK_FORMAT_B8G8R8A8_SSCALED:
+ case VK_FORMAT_B8G8R8A8_USCALED:
+ virglFormat = VIRGL_FORMAT_B8G8R8A8_UNORM;
+ break;
+ default:
+ break;
+ }
+
+ return virglFormat;
+}
+
CoherentMemoryPtr ResourceTracker::createCoherentMemory(
VkDevice device, VkDeviceMemory mem, const VkMemoryAllocateInfo& hostAllocationInfo,
VkEncoder* enc, VkResult& res) {
@@ -3221,6 +3282,13 @@
const void* importAhbInfoPtr = nullptr;
#endif
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ const VkImportMemoryFdInfoKHR* importFdInfoPtr =
+ vk_find_struct<VkImportMemoryFdInfoKHR>(pAllocateInfo);
+#else
+ const VkImportMemoryFdInfoKHR* importFdInfoPtr = nullptr;
+#endif
+
#ifdef VK_USE_PLATFORM_FUCHSIA
const VkImportMemoryBufferCollectionFUCHSIA* importBufferCollectionInfoPtr =
vk_find_struct<VkImportMemoryBufferCollectionFUCHSIA>(pAllocateInfo);
@@ -3268,9 +3336,11 @@
// State needed for import/export.
bool exportAhb = false;
bool exportVmo = false;
+ bool exportDmabuf = false;
bool importAhb = false;
bool importBufferCollection = false;
bool importVmo = false;
+ bool importDmabuf = false;
(void)exportVmo;
// Even if we export allocate, the underlying operation
@@ -3291,6 +3361,9 @@
exportVmo = exportAllocateInfoPtr->handleTypes &
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA;
#endif // VK_USE_PLATFORM_FUCHSIA
+ exportDmabuf =
+ exportAllocateInfoPtr->handleTypes & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
} else if (importAhbInfoPtr) {
importAhb = true;
} else if (importBufferCollectionInfoPtr) {
@@ -3298,7 +3371,13 @@
} else if (importVmoInfoPtr) {
importVmo = true;
}
- bool isImport = importAhb || importBufferCollection || importVmo;
+
+ if (importFdInfoPtr) {
+ importDmabuf =
+ (importFdInfoPtr->handleType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT));
+ }
+ bool isImport = importAhb || importBufferCollection || importVmo || importDmabuf;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
if (exportAhb) {
@@ -3671,7 +3750,96 @@
}
#endif
- if (ahw || !requestedMemoryIsHostVisible) {
+ VirtGpuBlobPtr colorBufferBlob = nullptr;
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ if (exportDmabuf) {
+ VirtGpuDevice* instance = VirtGpuDevice::getInstance();
+ // // TODO: any special action for VK_STRUCTURE_TYPE_WSI_MEMORY_ALLOCATE_INFO_MESA? Can mark
+ // special state if needed.
+ // // const wsi_memory_allocate_info* wsiAllocateInfoPtr =
+ // vk_find_struct<wsi_memory_allocate_info>(pAllocateInfo);
+ bool hasDedicatedImage =
+ dedicatedAllocInfoPtr && (dedicatedAllocInfoPtr->image != VK_NULL_HANDLE);
+ bool hasDedicatedBuffer =
+ dedicatedAllocInfoPtr && (dedicatedAllocInfoPtr->buffer != VK_NULL_HANDLE);
+ if (!hasDedicatedImage && !hasDedicatedBuffer) {
+ ALOGE(
+ "%s: dma-buf exportable memory requires dedicated Image or Buffer information.\n");
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
+
+ if (hasDedicatedImage) {
+ VkImageCreateInfo imageCreateInfo;
+ {
+ AutoLock<RecursiveLock> lock(mLock);
+
+ auto it = info_VkImage.find(dedicatedAllocInfoPtr->image);
+ if (it == info_VkImage.end()) return VK_ERROR_INITIALIZATION_FAILED;
+ const auto& imageInfo = it->second;
+
+ imageCreateInfo = imageInfo.createInfo;
+ }
+ uint32_t virglFormat = gfxstream::vk::getVirglFormat(imageCreateInfo.format);
+ if (virglFormat < 0) {
+ ALOGE("%s: Unsupported VK format for colorBuffer, vkFormat: 0x%x", __func__,
+ imageCreateInfo.format);
+ return VK_ERROR_FORMAT_NOT_SUPPORTED;
+ }
+ colorBufferBlob = instance->createVirglBlob(imageCreateInfo.extent.width,
+ imageCreateInfo.extent.height, virglFormat);
+ if (!colorBufferBlob) {
+ ALOGE("%s: Failed to create colorBuffer resource for Image memory\n", __func__);
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
+ if (0 != colorBufferBlob->wait()) {
+ ALOGE("%s: Failed to wait for colorBuffer resource for Image memory\n", __func__);
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
+ }
+
+ if (hasDedicatedBuffer) {
+ VkBufferCreateInfo bufferCreateInfo;
+ {
+ AutoLock<RecursiveLock> lock(mLock);
+
+ auto it = info_VkBuffer.find(dedicatedAllocInfoPtr->buffer);
+ if (it == info_VkBuffer.end()) return VK_ERROR_INITIALIZATION_FAILED;
+ const auto& bufferInfo = it->second;
+ bufferCreateInfo = bufferInfo.createInfo;
+ }
+ colorBufferBlob = instance->createVirglBlob(bufferCreateInfo.size / 4, 1,
+ VIRGL_FORMAT_R8G8B8A8_UNORM);
+ if (!colorBufferBlob) {
+ ALOGE("%s: Failed to create colorBuffer resource for Buffer memory\n", __func__);
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
+ if (0 != colorBufferBlob->wait()) {
+ ALOGE("%s: Failed to wait for colorBuffer resource for Buffer memory\n", __func__);
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
+ }
+ }
+
+ if (importDmabuf) {
+ VirtGpuExternalHandle importHandle = {};
+ importHandle.osHandle = importFdInfoPtr->fd;
+ importHandle.type = kMemHandleDmabuf;
+
+ auto instance = VirtGpuDevice::getInstance();
+ colorBufferBlob = instance->importBlob(importHandle);
+ if (!colorBufferBlob) {
+ ALOGE("%s: Failed to import colorBuffer resource\n", __func__);
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
+ }
+
+ if (colorBufferBlob) {
+ importCbInfo.colorBuffer = colorBufferBlob->getResourceHandle();
+ vk_append_struct(&structChainIter, &importCbInfo);
+ }
+#endif
+
+ if (ahw || colorBufferBlob || !requestedMemoryIsHostVisible) {
input_result =
enc->vkAllocateMemory(device, &finalAllocInfo, pAllocator, pMemory, true /* do lock */);
@@ -3679,7 +3847,7 @@
VkDeviceSize allocationSize = finalAllocInfo.allocationSize;
setDeviceMemoryInfo(device, *pMemory, 0, nullptr, finalAllocInfo.memoryTypeIndex, ahw,
- isImport, vmo_handle);
+ isImport, vmo_handle, colorBufferBlob);
_RETURN_SCUCCESS_WITH_DEVICE_MEMORY_REPORT;
}
@@ -3714,7 +3882,7 @@
setDeviceMemoryInfo(device, *pMemory, finalAllocInfo.allocationSize,
reinterpret_cast<uint8_t*>(addr), finalAllocInfo.memoryTypeIndex,
- /*ahw=*/nullptr, isImport, vmo_handle);
+ /*ahw=*/nullptr, isImport, vmo_handle, /*blobPtr=*/nullptr);
return VK_SUCCESS;
}
#endif
@@ -3857,11 +4025,11 @@
auto& info = it->second;
if (!info.external || !info.externalCreateInfo.handleTypes) {
- setMemoryRequirementsForSysmemBackedImage(image, &reqs2->memoryRequirements);
+ transformImageMemoryRequirementsForGuestLocked(image, &reqs2->memoryRequirements);
return;
}
- setMemoryRequirementsForSysmemBackedImage(image, &reqs2->memoryRequirements);
+ transformImageMemoryRequirementsForGuestLocked(image, &reqs2->memoryRequirements);
VkMemoryDedicatedRequirements* dedicatedReqs =
vk_find_struct<VkMemoryDedicatedRequirements>(reqs2);
@@ -3909,11 +4077,29 @@
const VkExternalMemoryImageCreateInfo* extImgCiPtr =
vk_find_struct<VkExternalMemoryImageCreateInfo>(pCreateInfo);
+
if (extImgCiPtr) {
localExtImgCi = vk_make_orphan_copy(*extImgCiPtr);
vk_append_struct(&structChainIter, &localExtImgCi);
}
+ bool isWsiImage = false;
+
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ if (extImgCiPtr &&
+ (extImgCiPtr->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)) {
+ // Assumes that handleType with DMA_BUF_BIT indicates creation of a
+ // image for WSI use; no other external dma_buf usage is supported
+ isWsiImage = true;
+ // Must be linear. Otherwise querying stride and other properties
+ // can be implementation-dependent.
+ localCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
+ if (gfxstream::vk::getVirglFormat(localCreateInfo.format) < 0) {
+ localCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
+ }
+ }
+#endif
+
#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkNativeBufferANDROID localAnb;
const VkNativeBufferANDROID* anbInfoPtr = vk_find_struct<VkNativeBufferANDROID>(pCreateInfo);
@@ -4085,13 +4271,16 @@
}
#endif
+ info.isWsiImage = isWsiImage;
+
// Delete `protocolVersion` check goldfish drivers are gone.
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
if (mCaps.vulkanCapset.colorBufferMemoryIndex == 0xFFFFFFFF) {
mCaps.vulkanCapset.colorBufferMemoryIndex = getColorBufferMemoryIndex(context, device);
}
- if (extImgCiPtr && (extImgCiPtr->handleTypes &
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)) {
+ if (isWsiImage ||
+ (extImgCiPtr && (extImgCiPtr->handleTypes &
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID))) {
updateMemoryTypeBits(&memReqs.memoryTypeBits, mCaps.vulkanCapset.colorBufferMemoryIndex);
}
#endif
@@ -4981,7 +5170,6 @@
vk_append_struct(&structChainIter, &localExtBufCi);
}
-
VkBufferOpaqueCaptureAddressCreateInfo localCapAddrCi;
const VkBufferOpaqueCaptureAddressCreateInfo* pCapAddrCi =
vk_find_struct<VkBufferOpaqueCaptureAddressCreateInfo>(pCreateInfo);
@@ -5057,12 +5245,14 @@
if (res != VK_SUCCESS) return res;
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
if (mCaps.vulkanCapset.colorBufferMemoryIndex == 0xFFFFFFFF) {
mCaps.vulkanCapset.colorBufferMemoryIndex = getColorBufferMemoryIndex(context, device);
}
- if (extBufCiPtr && (extBufCiPtr->handleTypes &
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)) {
+ if (extBufCiPtr &&
+ ((extBufCiPtr->handleTypes &
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) ||
+ (extBufCiPtr->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))) {
updateMemoryTypeBits(&memReqs.memoryTypeBits, mCaps.vulkanCapset.colorBufferMemoryIndex);
}
#endif
@@ -5354,6 +5544,53 @@
#endif
}
+VkResult ResourceTracker::on_vkGetMemoryFdKHR(void* context, VkResult, VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ if (!pGetFdInfo) return VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (!pGetFdInfo->memory) return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ if (!(pGetFdInfo->handleType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))) {
+ ALOGE("%s: Export operation not defined for handleType: 0x%x\n", __func__,
+ pGetFdInfo->handleType);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+ // Sanity-check device
+ AutoLock<RecursiveLock> lock(mLock);
+ auto deviceIt = info_VkDevice.find(device);
+ if (deviceIt == info_VkDevice.end()) {
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+
+ auto deviceMemIt = info_VkDeviceMemory.find(pGetFdInfo->memory);
+ if (deviceMemIt == info_VkDeviceMemory.end()) {
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+ auto& info = deviceMemIt->second;
+
+ if (!info.blobPtr) {
+ ALOGE("%s: VkDeviceMemory does not have a resource available for export.\n", __func__);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+
+ VirtGpuExternalHandle handle{};
+ int ret = info.blobPtr->exportBlob(handle);
+ if (ret != 0 || handle.osHandle < 0) {
+ ALOGE("%s: Failed to export host resource to FD.\n", __func__);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+ *pFd = handle.osHandle;
+ return VK_SUCCESS;
+#else
+ (void)context;
+ (void)device;
+ (void)pGetFdInfo;
+ (void)pFd;
+ return VK_ERROR_INCOMPATIBLE_DRIVER;
+#endif
+}
+
void ResourceTracker::flushCommandBufferPendingCommandsBottomUp(
void* context, VkQueue queue, const std::vector<VkCommandBuffer>& workingSet) {
if (workingSet.empty()) return;
@@ -5704,9 +5941,14 @@
}
auto* gralloc = ResourceTracker::threadingCallbacks.hostConnectionGetFunc()->grallocHelper();
+ const native_handle_t* nativeHandle = (const native_handle_t*)inputNativeInfo->handle;
- *(uint32_t*)(outputNativeInfo->handle) =
- gralloc->getHostHandle((const native_handle_t*)inputNativeInfo->handle);
+#if defined(END2END_TESTS)
+ // This is valid since the testing backend creates the handle and we know the layout.
+ *(uint32_t*)(outputNativeInfo->handle) = (uint32_t)nativeHandle->data[0];
+#else
+ *(uint32_t*)(outputNativeInfo->handle) = gralloc->getHostHandle(nativeHandle);
+#endif
}
void ResourceTracker::unwrap_VkBindImageMemorySwapchainInfoKHR(
@@ -6040,6 +6282,14 @@
memcpy(((uint8_t*)imageInfos) + currImageInfoOffset, user,
sizeof(VkDescriptorImageInfo));
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ // Convert mesa to internal for objects in the user buffer
+ VkDescriptorImageInfo* internalImageInfo =
+ (VkDescriptorImageInfo*)(((uint8_t*)imageInfos) + currImageInfoOffset);
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_image_view,
+ internalImageInfo->imageView);
+ internalImageInfo->imageView = gfxstream_image_view->internal_object;
+#endif
currImageInfoOffset += sizeof(VkDescriptorImageInfo);
}
@@ -6059,6 +6309,13 @@
memcpy(((uint8_t*)bufferInfos) + currBufferInfoOffset, user,
sizeof(VkDescriptorBufferInfo));
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ // Convert mesa to internal for objects in the user buffer
+ VkDescriptorBufferInfo* internalBufferInfo =
+ (VkDescriptorBufferInfo*)(((uint8_t*)bufferInfos) + currBufferInfoOffset);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internalBufferInfo->buffer);
+ internalBufferInfo->buffer = gfxstream_buffer->internal_object;
+#endif
currBufferInfoOffset += sizeof(VkDescriptorBufferInfo);
}
@@ -6077,6 +6334,15 @@
const VkBufferView* user = (const VkBufferView*)(userBuffer + offset + j * stride);
memcpy(((uint8_t*)bufferViews) + currBufferViewOffset, user, sizeof(VkBufferView));
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+ // Convert mesa to internal for objects in the user buffer
+ VkBufferView* internalBufferView =
+ (VkBufferView*)(((uint8_t*)bufferViews) + currBufferViewOffset);
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_buffer_view,
+ *internalBufferView);
+ *internalBufferView = gfxstream_buffer_view->internal_object;
+#endif
+
currBufferViewOffset += sizeof(VkBufferView);
}
@@ -6139,7 +6405,6 @@
VK_FORMAT_R8G8_SSCALED, VK_FORMAT_R8G8_SRGB,
};
-
if (ext_img_properties) {
if (std::find(std::begin(kExternalImageSupportedFormats),
std::end(kExternalImageSupportedFormats),
@@ -6154,7 +6419,7 @@
VkAndroidHardwareBufferUsageANDROID* output_ahw_usage =
vk_find_struct<VkAndroidHardwareBufferUsageANDROID>(pImageFormatProperties);
supportedHandleType |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
#endif
const VkPhysicalDeviceExternalImageFormatInfo* ext_img_info =
vk_find_struct<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo);
@@ -6201,7 +6466,8 @@
}
#endif
if (ext_img_properties) {
- transformImpl_VkExternalMemoryProperties_fromhost(&ext_img_properties->externalMemoryProperties, 0);
+ transformImpl_VkExternalMemoryProperties_fromhost(
+ &ext_img_properties->externalMemoryProperties, 0);
}
return hostRes;
}
@@ -6236,11 +6502,12 @@
#endif
#ifdef VK_USE_PLATFORM_ANDROID_KHR
supportedHandleType |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
#endif
if (supportedHandleType) {
// 0 is a valid handleType so we can't check against 0
- if (pExternalBufferInfo->handleType != (pExternalBufferInfo->handleType & supportedHandleType)) {
+ if (pExternalBufferInfo->handleType !=
+ (pExternalBufferInfo->handleType & supportedHandleType)) {
return;
}
}
@@ -6252,7 +6519,8 @@
enc->vkGetPhysicalDeviceExternalBufferProperties(
physicalDevice, pExternalBufferInfo, pExternalBufferProperties, true /* do lock */);
}
- transformImpl_VkExternalMemoryProperties_fromhost(&pExternalBufferProperties->externalMemoryProperties, 0);
+ transformImpl_VkExternalMemoryProperties_fromhost(
+ &pExternalBufferProperties->externalMemoryProperties, 0);
}
void ResourceTracker::on_vkGetPhysicalDeviceExternalBufferProperties(
@@ -6261,8 +6529,7 @@
VkExternalBufferProperties* pExternalBufferProperties) {
return on_vkGetPhysicalDeviceExternalBufferProperties_common(
false /* not KHR */, context, physicalDevice, pExternalBufferInfo,
- pExternalBufferProperties
- );
+ pExternalBufferProperties);
}
void ResourceTracker::on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
@@ -6270,9 +6537,7 @@
const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
VkExternalBufferPropertiesKHR* pExternalBufferProperties) {
return on_vkGetPhysicalDeviceExternalBufferProperties_common(
- true /* is KHR */, context, physicalDevice, pExternalBufferInfo,
- pExternalBufferProperties
- );
+ true /* is KHR */, context, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
void ResourceTracker::on_vkGetPhysicalDeviceExternalSemaphoreProperties(
@@ -6776,8 +7041,10 @@
vk_find_struct<VkPipelineRenderingCreateInfo>(&graphicsPipelineCreateInfo);
if (pipelineRenderingInfo) {
- forceDepthStencilState |= pipelineRenderingInfo->depthAttachmentFormat != VK_FORMAT_UNDEFINED;
- forceDepthStencilState |= pipelineRenderingInfo->stencilAttachmentFormat != VK_FORMAT_UNDEFINED;
+ forceDepthStencilState |=
+ pipelineRenderingInfo->depthAttachmentFormat != VK_FORMAT_UNDEFINED;
+ forceDepthStencilState |=
+ pipelineRenderingInfo->stencilAttachmentFormat != VK_FORMAT_UNDEFINED;
forceColorBlendState |= pipelineRenderingInfo->colorAttachmentCount != 0;
}
@@ -6998,7 +7265,8 @@
}
// static
-ALWAYS_INLINE VkEncoder* ResourceTracker::getCommandBufferEncoder(VkCommandBuffer commandBuffer) {
+ALWAYS_INLINE_GFXSTREAM VkEncoder* ResourceTracker::getCommandBufferEncoder(
+ VkCommandBuffer commandBuffer) {
if (!(ResourceTracker::streamFeatureBits &
VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT)) {
auto enc = ResourceTracker::getThreadLocalEncoder();
@@ -7019,7 +7287,7 @@
}
// static
-ALWAYS_INLINE VkEncoder* ResourceTracker::getQueueEncoder(VkQueue queue) {
+ALWAYS_INLINE_GFXSTREAM VkEncoder* ResourceTracker::getQueueEncoder(VkQueue queue) {
auto enc = ResourceTracker::getThreadLocalEncoder();
if (!(ResourceTracker::streamFeatureBits &
VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT)) {
@@ -7029,7 +7297,7 @@
}
// static
-ALWAYS_INLINE VkEncoder* ResourceTracker::getThreadLocalEncoder() {
+ALWAYS_INLINE_GFXSTREAM VkEncoder* ResourceTracker::getThreadLocalEncoder() {
auto hostConn = ResourceTracker::threadingCallbacks.hostConnectionGetFunc();
auto vkEncoder = ResourceTracker::threadingCallbacks.vkEncoderGetFunc(hostConn);
return vkEncoder;
@@ -7039,13 +7307,13 @@
void ResourceTracker::setSeqnoPtr(uint32_t* seqnoptr) { sSeqnoPtr = seqnoptr; }
// static
-ALWAYS_INLINE uint32_t ResourceTracker::nextSeqno() {
+ALWAYS_INLINE_GFXSTREAM uint32_t ResourceTracker::nextSeqno() {
uint32_t res = __atomic_add_fetch(sSeqnoPtr, 1, __ATOMIC_SEQ_CST);
return res;
}
// static
-ALWAYS_INLINE uint32_t ResourceTracker::getSeqno() {
+ALWAYS_INLINE_GFXSTREAM uint32_t ResourceTracker::getSeqno() {
uint32_t res = __atomic_load_n(sSeqnoPtr, __ATOMIC_SEQ_CST);
return res;
}
diff --git a/guest/vulkan_enc/ResourceTracker.h b/guest/vulkan_enc/ResourceTracker.h
index af34ab6..07e09cb 100644
--- a/guest/vulkan_enc/ResourceTracker.h
+++ b/guest/vulkan_enc/ResourceTracker.h
@@ -273,6 +273,9 @@
const VkBindImageMemoryInfo* inputBindInfos,
VkBindImageMemoryInfo* outputBindInfos);
+ VkResult on_vkGetMemoryFdKHR(void* context, VkResult input_result, VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
+
#ifdef VK_USE_PLATFORM_FUCHSIA
VkResult on_vkGetMemoryZirconHandleFUCHSIA(void* context, VkResult input_result,
VkDevice device,
@@ -541,9 +544,9 @@
void resetCommandPoolStagingInfo(VkCommandPool commandPool);
#ifdef __GNUC__
-#define ALWAYS_INLINE
+#define ALWAYS_INLINE_GFXSTREAM
#elif
-#define ALWAYS_INLINE __attribute__((always_inline))
+#define ALWAYS_INLINE_GFXSTREAM __attribute__((always_inline))
#endif
static VkEncoder* getCommandBufferEncoder(VkCommandBuffer commandBuffer);
@@ -551,8 +554,8 @@
static VkEncoder* getThreadLocalEncoder();
static void setSeqnoPtr(uint32_t* seqnoptr);
- static ALWAYS_INLINE uint32_t nextSeqno();
- static ALWAYS_INLINE uint32_t getSeqno();
+ static ALWAYS_INLINE_GFXSTREAM uint32_t nextSeqno();
+ static ALWAYS_INLINE_GFXSTREAM uint32_t getSeqno();
// Transforms
void deviceMemoryTransform_tohost(VkDeviceMemory* memory, uint32_t memoryCount,
@@ -614,7 +617,7 @@
void setDeviceMemoryInfo(VkDevice device, VkDeviceMemory memory, VkDeviceSize allocationSize,
uint8_t* ptr, uint32_t memoryTypeIndex, AHardwareBuffer* ahw,
- bool imported, zx_handle_t vmoHandle);
+ bool imported, zx_handle_t vmoHandle, VirtGpuBlobPtr blobPtr);
void setImageInfo(VkImage image, VkDevice device, const VkImageCreateInfo* pCreateInfo);
@@ -680,11 +683,6 @@
VkBindImageMemorySwapchainInfoKHR* outputBimsi);
#endif
- void setMemoryRequirementsForSysmemBackedImage(VkImage image,
- VkMemoryRequirements* pMemoryRequirements);
-
- void transformImageMemoryRequirementsForGuestLocked(VkImage image, VkMemoryRequirements* reqs);
-
#if defined(VK_USE_PLATFORM_FUCHSIA)
VkResult getBufferCollectionImageCreateInfoIndexLocked(
VkBufferCollectionFUCHSIA collection, fuchsia_sysmem::wire::BufferCollectionInfo2& info,
@@ -722,16 +720,17 @@
VkPhysicalDeviceMemoryProperties memProps;
uint32_t apiVersion;
std::set<std::string> enabledExtensions;
- std::vector<std::pair<PFN_vkDeviceMemoryReportCallbackEXT, void*>> deviceMemoryReportCallbacks;
+ std::vector<std::pair<PFN_vkDeviceMemoryReportCallbackEXT, void*>>
+ deviceMemoryReportCallbacks;
};
struct VkDeviceMemory_Info {
bool dedicated = false;
bool imported = false;
- #ifdef VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
AHardwareBuffer* ahw = nullptr;
- #endif
+#endif
zx_handle_t vmoHandle = ZX_HANDLE_INVALID;
VkDevice device;
@@ -743,10 +742,11 @@
uint64_t coherentMemorySize = 0;
uint64_t coherentMemoryOffset = 0;
- #if defined(__ANDROID__)
+#if defined(__ANDROID__)
GoldfishAddressSpaceBlockPtr goldfishBlock = nullptr;
- #endif // defined(__ANDROID__)
+#endif // defined(__ANDROID__)
CoherentMemoryPtr coherentMemory = nullptr;
+ VirtGpuBlobPtr blobPtr = nullptr;
};
struct VkCommandBuffer_Info {
@@ -768,14 +768,15 @@
VkDeviceSize currentBackingSize = 0;
bool baseRequirementsKnown = false;
VkMemoryRequirements baseRequirements;
- #ifdef VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
bool hasExternalFormat = false;
unsigned androidFormat = 0;
std::vector<int> pendingQsriSyncFds;
- #endif
- #ifdef VK_USE_PLATFORM_FUCHSIA
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
bool isSysmemBackedMemory = false;
- #endif
+#endif
+ bool isWsiImage = false;
};
struct VkBuffer_Info {
@@ -788,9 +789,9 @@
VkDeviceSize currentBackingSize = 0;
bool baseRequirementsKnown = false;
VkMemoryRequirements baseRequirements;
- #ifdef VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
bool isSysmemBackedMemory = false;
- #endif
+#endif
};
struct VkSemaphore_Info {
@@ -822,9 +823,9 @@
VkDevice device;
bool external = false;
VkExportFenceCreateInfo exportFenceCreateInfo;
- #if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
int syncFd = -1;
- #endif
+#endif
};
struct VkDescriptorPool_Info {
@@ -848,26 +849,23 @@
};
struct VkBufferCollectionFUCHSIA_Info {
- #ifdef VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
gfxstream::guest::Optional<fuchsia_sysmem::wire::BufferCollectionConstraints> constraints;
gfxstream::guest::Optional<VkBufferCollectionPropertiesFUCHSIA> properties;
// the index of corresponding createInfo for each image format
// constraints in |constraints|.
std::vector<uint32_t> createInfoIndex;
- #endif // VK_USE_PLATFORM_FUCHSIA
+#endif // VK_USE_PLATFORM_FUCHSIA
};
VkDescriptorImageInfo filterNonexistentSampler(const VkDescriptorImageInfo& inputInfo);
- void emitDeviceMemoryReport(VkDevice_Info info,
- VkDeviceMemoryReportEventTypeEXT type,
- uint64_t memoryObjectId,
- VkDeviceSize size,
- VkObjectType objectType,
- uint64_t objectHandle,
- uint32_t heapIndex = 0);
+ void emitDeviceMemoryReport(VkDevice_Info info, VkDeviceMemoryReportEventTypeEXT type,
+ uint64_t memoryObjectId, VkDeviceSize size, VkObjectType objectType,
+ uint64_t objectHandle, uint32_t heapIndex = 0);
+ void transformImageMemoryRequirementsForGuestLocked(VkImage image, VkMemoryRequirements* reqs);
CoherentMemoryPtr freeCoherentMemoryLocked(VkDeviceMemory memory, VkDeviceMemory_Info& info);
mutable RecursiveLock mLock;
@@ -893,10 +891,9 @@
fidl::WireSyncClient<fuchsia_sysmem::Allocator> mSysmemAllocator;
#endif
-#define HANDLE_REGISTER_DECLARATION(type) \
- std::unordered_map<type, type##_Info> info_##type;
+#define HANDLE_REGISTER_DECLARATION(type) std::unordered_map<type, type##_Info> info_##type;
-GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECLARATION)
+ GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECLARATION)
WorkPool mWorkPool{4};
std::unordered_map<VkQueue, std::vector<WorkPool::WaitGroupHandle>>
diff --git a/guest/vulkan_enc/Resources.cpp b/guest/vulkan_enc/Resources.cpp
index 00cfd9d..e60e950 100644
--- a/guest/vulkan_enc/Resources.cpp
+++ b/guest/vulkan_enc/Resources.cpp
@@ -19,10 +19,10 @@
#define GOLDFISH_VK_OBJECT_DEBUG 0
#if GOLDFISH_VK_OBJECT_DEBUG
-#define D(fmt,...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
+#define D(fmt, ...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
#else
#ifndef D
-#define D(fmt,...)
+#define D(fmt, ...)
#endif
#endif
@@ -36,105 +36,103 @@
#define SET_HWVULKAN_DISPATCH_MAGIC
#endif
-#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL(type) \
- type new_from_host_##type(type underlying) { \
- struct goldfish_##type* res = \
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL(type) \
+ type new_from_host_##type(type underlying) { \
+ struct goldfish_##type* res = \
static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
- if (!res) { \
- ALOGE("FATAL: Failed to alloc " #type " handle"); \
- abort(); \
- } \
- SET_HWVULKAN_DISPATCH_MAGIC \
- res->underlying = (uint64_t)underlying; \
- res->lastUsedEncoder = nullptr; \
- res->sequenceNumber = 0; \
- res->privateEncoder = 0; \
- res->privateStream = 0; \
- res->flags = 0; \
- res->poolObjects = 0; \
- res->subObjects = 0; \
- res->superObjects = 0; \
- res->userPtr = 0; \
- return reinterpret_cast<type>(res); \
- } \
+ if (!res) { \
+ ALOGE("FATAL: Failed to alloc " #type " handle"); \
+ abort(); \
+ } \
+ SET_HWVULKAN_DISPATCH_MAGIC \
+ res->underlying = (uint64_t)underlying; \
+ res->lastUsedEncoder = nullptr; \
+ res->sequenceNumber = 0; \
+ res->privateEncoder = 0; \
+ res->privateStream = 0; \
+ res->flags = 0; \
+ res->poolObjects = 0; \
+ res->subObjects = 0; \
+ res->superObjects = 0; \
+ res->userPtr = 0; \
+ return reinterpret_cast<type>(res); \
+ }
-#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL(type) \
- type new_from_host_##type(type underlying) { \
- struct goldfish_##type* res = \
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL(type) \
+ type new_from_host_##type(type underlying) { \
+ struct goldfish_##type* res = \
static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
- res->underlying = (uint64_t)underlying; \
- res->poolObjects = 0; \
- res->subObjects = 0; \
- res->superObjects = 0; \
- res->userPtr = 0; \
- return reinterpret_cast<type>(res); \
- } \
+ res->underlying = (uint64_t)underlying; \
+ res->poolObjects = 0; \
+ res->subObjects = 0; \
+ res->superObjects = 0; \
+ res->userPtr = 0; \
+ return reinterpret_cast<type>(res); \
+ }
-#define GOLDFISH_VK_AS_GOLDFISH_IMPL(type) \
+#define GOLDFISH_VK_AS_GOLDFISH_IMPL(type) \
struct goldfish_##type* as_goldfish_##type(type toCast) { \
- return reinterpret_cast<goldfish_##type*>(toCast); \
- } \
+ return reinterpret_cast<goldfish_##type*>(toCast); \
+ }
-#define GOLDFISH_VK_GET_HOST_IMPL(type) \
- type get_host_##type(type toUnwrap) { \
- if (!toUnwrap) return VK_NULL_HANDLE; \
+#define GOLDFISH_VK_GET_HOST_IMPL(type) \
+ type get_host_##type(type toUnwrap) { \
+ if (!toUnwrap) return VK_NULL_HANDLE; \
auto as_goldfish = as_goldfish_##type(toUnwrap); \
- return (type)(as_goldfish->underlying); \
- } \
+ return (type)(as_goldfish->underlying); \
+ }
-#define GOLDFISH_VK_DELETE_GOLDFISH_IMPL(type) \
+#define GOLDFISH_VK_DELETE_GOLDFISH_IMPL(type) \
void delete_goldfish_##type(type toDelete) { \
- D("guest %p", toDelete); \
- free(as_goldfish_##type(toDelete)); \
- } \
+ D("guest %p", toDelete); \
+ free(as_goldfish_##type(toDelete)); \
+ }
#define GOLDFISH_VK_IDENTITY_IMPL(type) \
- type vk_handle_identity_##type(type handle) { \
- return handle; \
- } \
+ type vk_handle_identity_##type(type handle) { return handle; }
-#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
- type new_from_host_u64_##type(uint64_t underlying) { \
- struct goldfish_##type* res = \
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
+ type new_from_host_u64_##type(uint64_t underlying) { \
+ struct goldfish_##type* res = \
static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
- if (!res) { \
- ALOGE("FATAL: Failed to alloc " #type " handle"); \
- abort(); \
- } \
- SET_HWVULKAN_DISPATCH_MAGIC \
- res->underlying = underlying; \
- res->lastUsedEncoder = nullptr; \
- res->sequenceNumber = 0; \
- res->privateEncoder = 0; \
- res->privateStream = 0; \
- res->flags = 0; \
- res->poolObjects = 0; \
- res->subObjects = 0; \
- res->superObjects = 0; \
- res->userPtr = 0; \
- return reinterpret_cast<type>(res); \
- } \
+ if (!res) { \
+ ALOGE("FATAL: Failed to alloc " #type " handle"); \
+ abort(); \
+ } \
+ SET_HWVULKAN_DISPATCH_MAGIC \
+ res->underlying = underlying; \
+ res->lastUsedEncoder = nullptr; \
+ res->sequenceNumber = 0; \
+ res->privateEncoder = 0; \
+ res->privateStream = 0; \
+ res->flags = 0; \
+ res->poolObjects = 0; \
+ res->subObjects = 0; \
+ res->superObjects = 0; \
+ res->userPtr = 0; \
+ return reinterpret_cast<type>(res); \
+ }
-#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
- type new_from_host_u64_##type(uint64_t underlying) { \
- struct goldfish_##type* res = \
- static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
- res->underlying = underlying; \
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
+ type new_from_host_u64_##type(uint64_t underlying) { \
+ struct goldfish_##type* res = \
+ static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+ res->underlying = underlying; \
D("guest %p: host u64: 0x%llx", res, (unsigned long long)res->underlying); \
- res->poolObjects = 0; \
- res->subObjects = 0; \
- res->superObjects = 0; \
- res->userPtr = 0; \
- return reinterpret_cast<type>(res); \
- } \
+ res->poolObjects = 0; \
+ res->subObjects = 0; \
+ res->superObjects = 0; \
+ res->userPtr = 0; \
+ return reinterpret_cast<type>(res); \
+ }
-#define GOLDFISH_VK_GET_HOST_U64_IMPL(type) \
- uint64_t get_host_u64_##type(type toUnwrap) { \
- if (!toUnwrap) return 0; \
- auto as_goldfish = as_goldfish_##type(toUnwrap); \
+#define GOLDFISH_VK_GET_HOST_U64_IMPL(type) \
+ uint64_t get_host_u64_##type(type toUnwrap) { \
+ if (!toUnwrap) return 0; \
+ auto as_goldfish = as_goldfish_##type(toUnwrap); \
D("guest %p: host u64: 0x%llx", toUnwrap, (unsigned long long)as_goldfish->underlying); \
- return as_goldfish->underlying; \
- } \
+ return as_goldfish->underlying; \
+ }
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL)
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_IMPL)
@@ -148,8 +146,10 @@
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_IMPL)
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_IMPL)
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_IMPL)
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL)
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(
+ GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(
+ GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL)
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_IMPL)
VkDescriptorPool new_from_host_VkDescriptorPool(VkDescriptorPool underlying) {
@@ -177,8 +177,8 @@
}
VkDescriptorSetLayout new_from_host_VkDescriptorSetLayout(VkDescriptorSetLayout underlying) {
- struct goldfish_VkDescriptorSetLayout* res =
- static_cast<goldfish_VkDescriptorSetLayout*>(malloc(sizeof(goldfish_VkDescriptorSetLayout)));
+ struct goldfish_VkDescriptorSetLayout* res = static_cast<goldfish_VkDescriptorSetLayout*>(
+ malloc(sizeof(goldfish_VkDescriptorSetLayout)));
res->underlying = (uint64_t)underlying;
res->layoutInfo = nullptr;
return reinterpret_cast<VkDescriptorSetLayout>(res);
@@ -188,7 +188,7 @@
return new_from_host_VkDescriptorSetLayout((VkDescriptorSetLayout)underlying);
}
-} // extern "C"
+} // extern "C"
namespace gfxstream {
namespace vk {
@@ -199,7 +199,11 @@
o->next = nullptr;
o->obj = val;
D("new ptr: %p", o);
- if (!*begin) { D("first"); *begin = o; return; }
+ if (!*begin) {
+ D("first");
+ *begin = o;
+ return;
+ }
struct goldfish_vk_object_list* q = *begin;
struct goldfish_vk_object_list* p = q;
@@ -214,7 +218,7 @@
}
void eraseObject(struct goldfish_vk_object_list** begin, void* val) {
- D("for val %p", val);
+ D("for val %p", val);
if (!*begin) {
D("val %p notfound", val);
return;
@@ -241,7 +245,7 @@
q = n;
}
- D("val %p notfound after looping", val);
+ D("val %p notfound after looping", val);
}
void eraseObjects(struct goldfish_vk_object_list** begin) {
diff --git a/guest/vulkan_enc/Resources.h b/guest/vulkan_enc/Resources.h
index 3e48f5c..1166da4 100644
--- a/guest/vulkan_enc/Resources.h
+++ b/guest/vulkan_enc/Resources.h
@@ -18,14 +18,13 @@
#elif defined(__linux__)
#include <vulkan/vk_icd.h>
#endif
+#include <inttypes.h>
#include <vulkan/vulkan.h>
-#include "VulkanHandles.h"
-
-#include <inttypes.h>
-
#include <functional>
+#include "VulkanHandles.h"
+
namespace gfxstream {
namespace guest {
class IOStream;
@@ -41,7 +40,6 @@
} // namespace vk
} // namespace gfxstream
-
extern "C" {
struct goldfish_vk_object_list {
@@ -58,51 +56,45 @@
#endif
#define GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT(type) \
- struct goldfish_##type { \
- DECLARE_HWVULKAN_DISPATCH \
- uint64_t underlying; \
- gfxstream::vk::VkEncoder* lastUsedEncoder; \
- uint32_t sequenceNumber; \
- gfxstream::vk::VkEncoder* privateEncoder; \
- gfxstream::guest::IOStream* privateStream; \
- uint32_t flags; \
- struct goldfish_vk_object_list* poolObjects; \
- struct goldfish_vk_object_list* subObjects; \
- struct goldfish_vk_object_list* superObjects; \
- void* userPtr; \
- }; \
+ struct goldfish_##type { \
+ DECLARE_HWVULKAN_DISPATCH \
+ uint64_t underlying; \
+ gfxstream::vk::VkEncoder* lastUsedEncoder; \
+ uint32_t sequenceNumber; \
+ gfxstream::vk::VkEncoder* privateEncoder; \
+ gfxstream::guest::IOStream* privateStream; \
+ uint32_t flags; \
+ struct goldfish_vk_object_list* poolObjects; \
+ struct goldfish_vk_object_list* subObjects; \
+ struct goldfish_vk_object_list* superObjects; \
+ void* userPtr; \
+ };
#define GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT(type) \
- struct goldfish_##type { \
- uint64_t underlying; \
- struct goldfish_vk_object_list* poolObjects; \
- struct goldfish_vk_object_list* subObjects; \
- struct goldfish_vk_object_list* superObjects; \
- void* userPtr; \
- }; \
+ struct goldfish_##type { \
+ uint64_t underlying; \
+ struct goldfish_vk_object_list* poolObjects; \
+ struct goldfish_vk_object_list* subObjects; \
+ struct goldfish_vk_object_list* superObjects; \
+ void* userPtr; \
+ };
-#define GOLDFISH_VK_NEW_FROM_HOST_DECL(type) \
- type new_from_host_##type(type);
+#define GOLDFISH_VK_NEW_FROM_HOST_DECL(type) type new_from_host_##type(type);
-#define GOLDFISH_VK_AS_GOLDFISH_DECL(type) \
- struct goldfish_##type* as_goldfish_##type(type);
+#define GOLDFISH_VK_AS_GOLDFISH_DECL(type) struct goldfish_##type* as_goldfish_##type(type);
-#define GOLDFISH_VK_GET_HOST_DECL(type) \
- type get_host_##type(type);
+#define GOLDFISH_VK_GET_HOST_DECL(type) type get_host_##type(type);
-#define GOLDFISH_VK_DELETE_GOLDFISH_DECL(type) \
- void delete_goldfish_##type(type);
+#define GOLDFISH_VK_DELETE_GOLDFISH_DECL(type) void delete_goldfish_##type(type);
-#define GOLDFISH_VK_IDENTITY_DECL(type) \
- type vk_handle_identity_##type(type);
+#define GOLDFISH_VK_IDENTITY_DECL(type) type vk_handle_identity_##type(type);
-#define GOLDFISH_VK_NEW_FROM_HOST_U64_DECL(type) \
- type new_from_host_u64_##type(uint64_t);
+#define GOLDFISH_VK_NEW_FROM_HOST_U64_DECL(type) type new_from_host_u64_##type(uint64_t);
-#define GOLDFISH_VK_GET_HOST_U64_DECL(type) \
- uint64_t get_host_u64_##type(type);
+#define GOLDFISH_VK_GET_HOST_U64_DECL(type) uint64_t get_host_u64_##type(type);
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(
+ GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT)
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_DECL)
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_DECL)
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_DECL)
@@ -118,7 +110,8 @@
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_DECL)
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_U64_DECL)
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_DECL)
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(
+ GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT)
struct goldfish_VkDescriptorPool {
uint64_t underlying;
@@ -151,7 +144,7 @@
VkDevice device;
};
-} // extern "C"
+} // extern "C"
namespace gfxstream {
namespace vk {
diff --git a/guest/vulkan_enc/Validation.cpp b/guest/vulkan_enc/Validation.cpp
index 3b75786..00652fc 100644
--- a/guest/vulkan_enc/Validation.cpp
+++ b/guest/vulkan_enc/Validation.cpp
@@ -13,19 +13,15 @@
// limitations under the License.
#include "Validation.h"
-#include "Resources.h"
#include "ResourceTracker.h"
+#include "Resources.h"
namespace gfxstream {
namespace vk {
-VkResult Validation::on_vkFlushMappedMemoryRanges(
- void*,
- VkResult,
- VkDevice,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
-
+VkResult Validation::on_vkFlushMappedMemoryRanges(void*, VkResult, VkDevice,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
auto resources = ResourceTracker::get();
for (uint32_t i = 0; i < memoryRangeCount; ++i) {
@@ -37,13 +33,9 @@
return VK_SUCCESS;
}
-VkResult Validation::on_vkInvalidateMappedMemoryRanges(
- void*,
- VkResult,
- VkDevice,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
-
+VkResult Validation::on_vkInvalidateMappedMemoryRanges(void*, VkResult, VkDevice,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
auto resources = ResourceTracker::get();
for (uint32_t i = 0; i < memoryRangeCount; ++i) {
diff --git a/guest/vulkan_enc/Validation.h b/guest/vulkan_enc/Validation.h
index 0dfd2d3..e4ebc5f 100644
--- a/guest/vulkan_enc/Validation.h
+++ b/guest/vulkan_enc/Validation.h
@@ -19,19 +19,13 @@
namespace vk {
class Validation {
-public:
- VkResult on_vkFlushMappedMemoryRanges(
- void* context,
- VkResult input_result,
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges);
- VkResult on_vkInvalidateMappedMemoryRanges(
- void* context,
- VkResult input_result,
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges);
+ public:
+ VkResult on_vkFlushMappedMemoryRanges(void* context, VkResult input_result, VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+ VkResult on_vkInvalidateMappedMemoryRanges(void* context, VkResult input_result,
+ VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
};
} // namespace vk
diff --git a/guest/vulkan_enc/VkEncoder.cpp b/guest/vulkan_enc/VkEncoder.cpp
index a3b2ddd..c9ef5c4 100644
--- a/guest/vulkan_enc/VkEncoder.cpp
+++ b/guest/vulkan_enc/VkEncoder.cpp
@@ -33178,6 +33178,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -39161,6 +39163,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/guest/vulkan_enc/VkEncoder.h b/guest/vulkan_enc/VkEncoder.h
index 794db47..5a40b30 100644
--- a/guest/vulkan_enc/VkEncoder.h
+++ b/guest/vulkan_enc/VkEncoder.h
@@ -919,6 +919,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -1133,6 +1135,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
private:
class Impl;
diff --git a/guest/vulkan_enc/VulkanHandleMapping.cpp b/guest/vulkan_enc/VulkanHandleMapping.cpp
index 068e666..1b5c6a6 100644
--- a/guest/vulkan_enc/VulkanHandleMapping.cpp
+++ b/guest/vulkan_enc/VulkanHandleMapping.cpp
@@ -12,24 +12,29 @@
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
-#include <vulkan/vulkan.h>
-
#include "VulkanHandleMapping.h"
+#include <vulkan/vulkan.h>
+
namespace gfxstream {
namespace vk {
-#define DEFAULT_HANDLE_MAP_DEFINE(type) \
-void DefaultHandleMapping::mapHandles_##type(type*, size_t) { return; } \
-void DefaultHandleMapping::mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) { \
- for (size_t i = 0; i < count; ++i) { handle_u64s[i] = (uint64_t)(uintptr_t)handles[i]; } \
-} \
-void DefaultHandleMapping::mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) { \
- for (size_t i = 0; i < count; ++i) { handles[i] = (type)(uintptr_t)handle_u64s[i]; } \
-} \
+#define DEFAULT_HANDLE_MAP_DEFINE(type) \
+ void DefaultHandleMapping::mapHandles_##type(type*, size_t) { return; } \
+ void DefaultHandleMapping::mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, \
+ size_t count) { \
+ for (size_t i = 0; i < count; ++i) { \
+ handle_u64s[i] = (uint64_t)(uintptr_t)handles[i]; \
+ } \
+ } \
+ void DefaultHandleMapping::mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, \
+ size_t count) { \
+ for (size_t i = 0; i < count; ++i) { \
+ handles[i] = (type)(uintptr_t)handle_u64s[i]; \
+ } \
+ }
GOLDFISH_VK_LIST_HANDLE_TYPES(DEFAULT_HANDLE_MAP_DEFINE)
} // namespace vk
} // namespace gfxstream
-
diff --git a/guest/vulkan_enc/VulkanHandleMapping.h b/guest/vulkan_enc/VulkanHandleMapping.h
index 7c7fdbc..08c229e 100644
--- a/guest/vulkan_enc/VulkanHandleMapping.h
+++ b/guest/vulkan_enc/VulkanHandleMapping.h
@@ -22,26 +22,29 @@
namespace vk {
class VulkanHandleMapping {
-public:
+ public:
VulkanHandleMapping() = default;
- virtual ~VulkanHandleMapping() { }
+ virtual ~VulkanHandleMapping() {}
-#define DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD(type) \
- virtual void mapHandles_##type(type* handles, size_t count = 1) = 0; \
- virtual void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count = 1) = 0; \
- virtual void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count = 1) = 0; \
+#define DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD(type) \
+ virtual void mapHandles_##type(type* handles, size_t count = 1) = 0; \
+ virtual void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, \
+ size_t count = 1) = 0; \
+ virtual void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, \
+ size_t count = 1) = 0;
GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD)
};
class DefaultHandleMapping : public VulkanHandleMapping {
-public:
- virtual ~DefaultHandleMapping() { }
+ public:
+ virtual ~DefaultHandleMapping() {}
-#define DECLARE_HANDLE_MAP_OVERRIDE(type) \
- void mapHandles_##type(type* handles, size_t count) override; \
- void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) override; \
- void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) override; \
+#define DECLARE_HANDLE_MAP_OVERRIDE(type) \
+ void mapHandles_##type(type* handles, size_t count) override; \
+ void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) \
+ override; \
+ void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) override;
GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_OVERRIDE)
};
diff --git a/guest/vulkan_enc/VulkanHandles.h b/guest/vulkan_enc/VulkanHandles.h
index cdec839..1be4d70 100644
--- a/guest/vulkan_enc/VulkanHandles.h
+++ b/guest/vulkan_enc/VulkanHandles.h
@@ -19,77 +19,75 @@
namespace gfxstream {
namespace vk {
-#define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
- f(VkPhysicalDevice) \
+#define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) f(VkPhysicalDevice)
#define GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
- f(VkInstance) \
- f(VkDevice) \
- f(VkCommandBuffer) \
- f(VkQueue) \
+ f(VkInstance) \
+ f(VkDevice) \
+ f(VkCommandBuffer) \
+ f(VkQueue) \
GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
#ifdef VK_NVX_binary_import
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f) \
- f(VkCuModuleNVX) \
- f(VkCuFunctionNVX) \
+ f(VkCuModuleNVX) \
+ f(VkCuFunctionNVX)
#else
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f)
-#endif // VK_NVX_binary_import
+#endif // VK_NVX_binary_import
#ifdef VK_NVX_device_generated_commands
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_DEVICE_GENERATED_COMMANDS(f) \
- f(VkObjectTableNVX) \
- f(VkIndirectCommandsLayoutNVX) \
+ f(VkObjectTableNVX) \
+ f(VkIndirectCommandsLayoutNVX)
#else
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_DEVICE_GENERATED_COMMANDS(f)
-#endif // VK_NVX_device_generated_commands
+#endif // VK_NVX_device_generated_commands
#ifdef VK_NV_device_generated_commands
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f) \
- f(VkIndirectCommandsLayoutNV) \
+ f(VkIndirectCommandsLayoutNV)
#else
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f)
-#endif // VK_NV_device_generated_commands
+#endif // VK_NV_device_generated_commands
#ifdef VK_NV_ray_tracing
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f) \
- f(VkAccelerationStructureNV) \
+ f(VkAccelerationStructureNV)
#else
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f)
-#endif // VK_NV_ray_tracing
+#endif // VK_NV_ray_tracing
#ifdef VK_KHR_acceleration_structure
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f) \
- f(VkAccelerationStructureKHR) \
+ f(VkAccelerationStructureKHR)
#else
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f)
-#endif // VK_KHR_acceleration_structure
+#endif // VK_KHR_acceleration_structure
#ifdef VK_USE_PLATFORM_FUCHSIA
-#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
- f(VkBufferCollectionFUCHSIA)
+#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) f(VkBufferCollectionFUCHSIA)
#else
@@ -97,77 +95,77 @@
#endif // VK_USE_PLATFORM_FUCHSIA
-#define GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
- f(VkBufferView) \
- f(VkImageView) \
- f(VkShaderModule) \
- f(VkPipeline) \
- f(VkPipelineCache) \
- f(VkPipelineLayout) \
- f(VkRenderPass) \
- f(VkFramebuffer) \
- f(VkEvent) \
- f(VkQueryPool) \
- f(VkSamplerYcbcrConversion) \
- f(VkSurfaceKHR) \
- f(VkSwapchainKHR) \
- f(VkDisplayKHR) \
- f(VkDisplayModeKHR) \
- f(VkValidationCacheEXT) \
- f(VkDebugReportCallbackEXT) \
- f(VkDebugUtilsMessengerEXT) \
- f(VkMicromapEXT) \
- __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f) \
+#define GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkBufferView) \
+ f(VkImageView) \
+ f(VkShaderModule) \
+ f(VkPipeline) \
+ f(VkPipelineCache) \
+ f(VkPipelineLayout) \
+ f(VkRenderPass) \
+ f(VkFramebuffer) \
+ f(VkEvent) \
+ f(VkQueryPool) \
+ f(VkSamplerYcbcrConversion) \
+ f(VkSurfaceKHR) \
+ f(VkSwapchainKHR) \
+ f(VkDisplayKHR) \
+ f(VkDisplayModeKHR) \
+ f(VkValidationCacheEXT) \
+ f(VkDebugReportCallbackEXT) \
+ f(VkDebugUtilsMessengerEXT) \
+ f(VkMicromapEXT) \
+ __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f) \
__GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_DEVICE_GENERATED_COMMANDS(f) \
- __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f) \
- __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f) \
- __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f) \
+ __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f) \
+ __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f) \
+ __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f)
-#define GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f) \
- f(VkDeviceMemory) \
- f(VkBuffer) \
- f(VkImage) \
- f(VkSemaphore) \
- f(VkDescriptorUpdateTemplate) \
- f(VkFence) \
- f(VkDescriptorPool) \
- f(VkDescriptorSet) \
- f(VkDescriptorSetLayout) \
- f(VkCommandPool) \
- f(VkSampler) \
+#define GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkDeviceMemory) \
+ f(VkBuffer) \
+ f(VkImage) \
+ f(VkSemaphore) \
+ f(VkDescriptorUpdateTemplate) \
+ f(VkFence) \
+ f(VkDescriptorPool) \
+ f(VkDescriptorSet) \
+ f(VkDescriptorSetLayout) \
+ f(VkCommandPool) \
+ f(VkSampler) \
__GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
- GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+ GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
-#define GOLDFISH_VK_LIST_HANDLE_TYPES(f) \
+#define GOLDFISH_VK_LIST_HANDLE_TYPES(f) \
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f)
-#define GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(f) \
+#define GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(f) \
GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
#define GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(f) \
- f(VkInstance) \
- f(VkDevice) \
- f(VkQueue) \
+ f(VkInstance) \
+ f(VkDevice) \
+ f(VkQueue) \
GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
#define GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(f) \
- f(VkDeviceMemory) \
- f(VkBuffer) \
- f(VkImage) \
- f(VkSemaphore) \
- f(VkFence) \
- f(VkDescriptorUpdateTemplate) \
- f(VkCommandPool) \
- f(VkSampler) \
- __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
- GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkDeviceMemory) \
+ f(VkBuffer) \
+ f(VkImage) \
+ f(VkSemaphore) \
+ f(VkFence) \
+ f(VkDescriptorUpdateTemplate) \
+ f(VkCommandPool) \
+ f(VkSampler) \
+ __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
+ GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
#define GOLDFISH_VK_LIST_MANUAL_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(f) \
- f(VkDescriptorPool) \
- f(VkDescriptorSetLayout) \
- f(VkDescriptorSet) \
+ f(VkDescriptorPool) \
+ f(VkDescriptorSetLayout) \
+ f(VkDescriptorSet)
} // namespace vk
} // namespace gfxstream
diff --git a/guest/vulkan_enc/VulkanStreamGuest.cpp b/guest/vulkan_enc/VulkanStreamGuest.cpp
index 459da45..53d4ad5 100644
--- a/guest/vulkan_enc/VulkanStreamGuest.cpp
+++ b/guest/vulkan_enc/VulkanStreamGuest.cpp
@@ -16,16 +16,14 @@
namespace gfxstream {
namespace vk {
-VulkanStreamGuest::VulkanStreamGuest(gfxstream::guest::IOStream *stream): mStream(stream) {
+VulkanStreamGuest::VulkanStreamGuest(gfxstream::guest::IOStream* stream) : mStream(stream) {
unsetHandleMapping();
mFeatureBits = ResourceTracker::get()->getStreamFeatures();
}
VulkanStreamGuest::~VulkanStreamGuest() = default;
-bool VulkanStreamGuest::valid() {
- return true;
-}
+bool VulkanStreamGuest::valid() { return true; }
void VulkanStreamGuest::alloc(void** ptrAddr, size_t bytes) {
if (!bytes) {
@@ -56,7 +54,7 @@
alloc((void**)forOutput, count * sizeof(char*));
- char **stringsForOutput = *forOutput;
+ char** stringsForOutput = *forOutput;
for (size_t i = 0; i < count; i++) {
loadStringInPlace(stringsForOutput + i);
@@ -79,8 +77,9 @@
}
}
-void VulkanStreamGuest::loadStringArrayInPlaceWithStreamPtr(char*** forOutput, uint8_t** streamPtr) {
- uint32_t count;
+void VulkanStreamGuest::loadStringArrayInPlaceWithStreamPtr(char*** forOutput,
+ uint8_t** streamPtr) {
+ uint32_t count;
memcpy(&count, *streamPtr, sizeof(uint32_t));
*streamPtr += sizeof(uint32_t);
gfxstream::guest::Stream::fromBe32((uint8_t*)&count);
@@ -91,15 +90,14 @@
alloc((void**)forOutput, count * sizeof(char*));
- char **stringsForOutput = *forOutput;
+ char** stringsForOutput = *forOutput;
for (size_t i = 0; i < count; i++) {
loadStringInPlaceWithStreamPtr(stringsForOutput + i, streamPtr);
}
}
-
-ssize_t VulkanStreamGuest::read(void *buffer, size_t size) {
+ssize_t VulkanStreamGuest::read(void* buffer, size_t size) {
if (!mStream->readback(buffer, size)) {
ALOGE("FATAL: Could not read back %zu bytes", size);
abort();
@@ -107,7 +105,7 @@
return size;
}
-ssize_t VulkanStreamGuest::write(const void *buffer, size_t size) {
+ssize_t VulkanStreamGuest::write(const void* buffer, size_t size) {
uint8_t* streamBuf = (uint8_t*)mStream->alloc(size);
memcpy(streamBuf, buffer, size);
return size;
@@ -117,44 +115,30 @@
mStream->writeFullyAsync(buffer, size);
}
-void VulkanStreamGuest::clearPool() {
- mPool.freeAll();
-}
+void VulkanStreamGuest::clearPool() { mPool.freeAll(); }
void VulkanStreamGuest::setHandleMapping(VulkanHandleMapping* mapping) {
mCurrentHandleMapping = mapping;
}
-void VulkanStreamGuest::unsetHandleMapping() {
- mCurrentHandleMapping = &mDefaultHandleMapping;
-}
+void VulkanStreamGuest::unsetHandleMapping() { mCurrentHandleMapping = &mDefaultHandleMapping; }
-VulkanHandleMapping* VulkanStreamGuest::handleMapping() const {
- return mCurrentHandleMapping;
-}
+VulkanHandleMapping* VulkanStreamGuest::handleMapping() const { return mCurrentHandleMapping; }
void VulkanStreamGuest::flush() {
AEMU_SCOPED_TRACE("VulkanStreamGuest device write");
mStream->flush();
}
-uint32_t VulkanStreamGuest::getFeatureBits() const {
- return mFeatureBits;
-}
+uint32_t VulkanStreamGuest::getFeatureBits() const { return mFeatureBits; }
-void VulkanStreamGuest::incStreamRef() {
- mStream->incRef();
-}
+void VulkanStreamGuest::incStreamRef() { mStream->incRef(); }
-bool VulkanStreamGuest::decStreamRef() {
- return mStream->decRef();
-}
+bool VulkanStreamGuest::decStreamRef() { return mStream->decRef(); }
-uint8_t* VulkanStreamGuest::reserve(size_t size) {
- return (uint8_t*)mStream->alloc(size);
-}
+uint8_t* VulkanStreamGuest::reserve(size_t size) { return (uint8_t*)mStream->alloc(size); }
-VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) { }
+VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) {}
VulkanCountingStream::~VulkanCountingStream() = default;
ssize_t VulkanCountingStream::read(void*, size_t size) {
diff --git a/guest/vulkan_enc/VulkanStreamGuest.h b/guest/vulkan_enc/VulkanStreamGuest.h
index ae995e1..92052af 100644
--- a/guest/vulkan_enc/VulkanStreamGuest.h
+++ b/guest/vulkan_enc/VulkanStreamGuest.h
@@ -13,30 +13,26 @@
// limitations under the License.
#pragma once
-#include "aemu/base/files/Stream.h"
-#include "aemu/base/files/StreamSerializing.h"
+#include <inttypes.h>
+#include <log/log.h>
-#include "goldfish_vk_private_defs.h"
-
-#include "VulkanHandleMapping.h"
+#include <memory>
+#include <vector>
#include "gfxstream/guest/IOStream.h"
#include "ResourceTracker.h"
-
+#include "VulkanHandleMapping.h"
#include "aemu/base/BumpPool.h"
#include "aemu/base/Tracing.h"
-
-#include <vector>
-#include <memory>
-
-#include <log/log.h>
-#include <inttypes.h>
+#include "aemu/base/files/Stream.h"
+#include "aemu/base/files/StreamSerializing.h"
+#include "goldfish_vk_private_defs.h"
namespace gfxstream {
namespace vk {
class VulkanStreamGuest : public gfxstream::guest::Stream {
-public:
+ public:
VulkanStreamGuest(gfxstream::guest::IOStream* stream);
~VulkanStreamGuest();
@@ -55,8 +51,8 @@
void loadStringInPlaceWithStreamPtr(char** forOutput, uint8_t** streamPtr);
void loadStringArrayInPlaceWithStreamPtr(char*** forOutput, uint8_t** streamPtr);
- ssize_t read(void *buffer, size_t size) override;
- ssize_t write(const void *buffer, size_t size) override;
+ ssize_t read(void* buffer, size_t size) override;
+ ssize_t write(const void* buffer, size_t size) override;
void writeLarge(const void* buffer, size_t size);
@@ -75,7 +71,8 @@
bool decStreamRef();
uint8_t* reserve(size_t size);
-private:
+
+ private:
gfxstream::guest::BumpPool mPool;
std::vector<uint8_t> mWriteBuffer;
gfxstream::guest::IOStream* mStream = nullptr;
@@ -85,18 +82,19 @@
};
class VulkanCountingStream : public VulkanStreamGuest {
-public:
+ public:
VulkanCountingStream();
~VulkanCountingStream();
- ssize_t read(void *buffer, size_t size) override;
- ssize_t write(const void *buffer, size_t size) override;
+ ssize_t read(void* buffer, size_t size) override;
+ ssize_t write(const void* buffer, size_t size) override;
size_t bytesWritten() const { return m_written; }
size_t bytesRead() const { return m_read; }
void rewind();
-private:
+
+ private:
size_t m_written = 0;
size_t m_read = 0;
};
diff --git a/guest/vulkan_enc/func_table.cpp b/guest/vulkan_enc/func_table.cpp
index e05ac1e..c4408c3 100644
--- a/guest/vulkan_enc/func_table.cpp
+++ b/guest/vulkan_enc/func_table.cpp
@@ -30,8 +30,6 @@
// $CEREAL_OUTPUT_DIR
//
-#include "func_table.h"
-
#include <log/log.h>
#include <cstring>
@@ -39,6 +37,8 @@
#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
#include "VkEncoder.h"
+#include "gfxstream_vk_entrypoints.h"
+#include "gfxstream_vk_private.h"
#include "goldfish_vk_private_defs.h"
// Stuff we are not going to use but if included,
@@ -49,2119 +49,3668 @@
#if defined(LINUX_GUEST_BUILD) || defined(__Fuchsia__)
#undef VK_ANDROID_native_buffer
#endif
-
-namespace gfxstream {
-namespace vk {
-
-static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature) {
- ALOGE("invalid call to %s: %s not supported", apiname, neededFeature);
- abort();
-}
#ifdef VK_VERSION_1_0
-static VkResult entry_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkInstance* pInstance) {
- AEMU_SCOPED_TRACE("vkCreateInstance");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateInstance_VkResult_return = (VkResult)0;
- vkCreateInstance_VkResult_return =
- vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance, true /* do lock */);
- return vkCreateInstance_VkResult_return;
-}
-static void entry_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyInstance");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyInstance(instance, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkEnumeratePhysicalDevices(VkInstance instance,
- uint32_t* pPhysicalDeviceCount,
- VkPhysicalDevice* pPhysicalDevices) {
- AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(
- vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
- return vkEnumeratePhysicalDevices_VkResult_return;
-}
-static void entry_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures(gfxstream_physicalDevice->internal_object, pFeatures,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties(gfxstream_physicalDevice->internal_object,
+ format, pFormatProperties, true /* do lock */);
+ }
}
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
VkImageUsageFlags usage, VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
- vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage,
- flags, pImageFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceImageFormatProperties(
+ gfxstream_physicalDevice->internal_object, format, type, tiling, usage, flags,
+ pImageFormatProperties, true /* do lock */);
+ }
return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties(gfxstream_physicalDevice->internal_object, pProperties,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(gfxstream_physicalDevice->internal_object,
+ pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceMemoryProperties(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties(gfxstream_physicalDevice->internal_object,
+ pMemoryProperties, true /* do lock */);
+ }
}
-static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
- AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
- vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
- vkEnc->vkGetInstanceProcAddr(instance, pName, true /* do lock */);
- return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
-}
-static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
- AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
- vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
- vkEnc->vkGetDeviceProcAddr(device, pName, true /* do lock */);
- return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
-}
-static VkResult entry_vkCreateDevice(VkPhysicalDevice physicalDevice,
- const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
- AEMU_SCOPED_TRACE("vkCreateDevice");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateDevice_VkResult_return = (VkResult)0;
- vkCreateDevice_VkResult_return =
- vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice, true /* do lock */);
- return vkCreateDevice_VkResult_return;
-}
-static void entry_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyDevice");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDevice(device, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkEnumerateInstanceExtensionProperties(const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEnumerateInstanceExtensionProperties_VkResult_return =
- resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName,
- pPropertyCount, pProperties);
- return vkEnumerateInstanceExtensionProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEnumerateDeviceExtensionProperties_VkResult_return =
- resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice,
- pLayerName, pPropertyCount, pProperties);
- return vkEnumerateDeviceExtensionProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
- VkLayerProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
- vkEnumerateInstanceLayerProperties_VkResult_return =
- vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties, true /* do lock */);
- return vkEnumerateInstanceLayerProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties) {
+VkResult gfxstream_vk_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
- vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
- physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
+ gfxstream_physicalDevice->internal_object, pPropertyCount, pProperties,
+ true /* do lock */);
+ }
return vkEnumerateDeviceLayerProperties_VkResult_return;
}
-static void entry_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
- VkQueue* pQueue) {
- AEMU_SCOPED_TRACE("vkGetDeviceQueue");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, true /* do lock */);
-}
-static VkResult entry_vkQueueSubmit(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
+ VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueSubmit_VkResult_return =
- resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
+ std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo::pWaitSemaphores */
+ internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
+ internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
+ internal_pSubmits[i].waitSemaphoreCount =
+ internal_VkSubmitInfo_pWaitSemaphores[i].size();
+ /* VkSubmitInfo::pCommandBuffers */
+ internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
+ internal_VkSubmitInfo_pCommandBuffers[i].reserve(
+ internal_pSubmits[i].commandBufferCount);
+ memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
+ sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+ internal_pSubmits[i].pCommandBuffers[j]);
+ internal_VkSubmitInfo_pCommandBuffers[i][j] =
+ gfxstream_pCommandBuffers->internal_object;
+ }
+ internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
+ /* VkSubmitInfo::pSignalSemaphores */
+ internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
+ internal_pSubmits[i].pSignalSemaphores =
+ internal_VkSubmitInfo_pSignalSemaphores[i].data();
+ internal_pSubmits[i].signalSemaphoreCount =
+ internal_VkSubmitInfo_pSignalSemaphores[i].size();
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(
+ vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
+ internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
+ }
return vkQueueSubmit_VkResult_return;
}
-static VkResult entry_vkQueueWaitIdle(VkQueue queue) {
+VkResult gfxstream_vk_QueueWaitIdle(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueWaitIdle");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueWaitIdle_VkResult_return =
+ resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, gfxstream_queue->internal_object);
+ }
return vkQueueWaitIdle_VkResult_return;
}
-static VkResult entry_vkDeviceWaitIdle(VkDevice device) {
+VkResult gfxstream_vk_DeviceWaitIdle(VkDevice device) {
AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
- vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkDeviceWaitIdle_VkResult_return =
+ vkEnc->vkDeviceWaitIdle(gfxstream_device->internal_object, true /* do lock */);
+ }
return vkDeviceWaitIdle_VkResult_return;
}
-static VkResult entry_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDeviceMemory* pMemory) {
- AEMU_SCOPED_TRACE("vkAllocateMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
- vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
- return vkAllocateMemory_VkResult_return;
-}
-static void entry_vkFreeMemory(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_FreeMemory(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkFreeMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator);
+ if (VK_NULL_HANDLE == memory) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkFreeMemory(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator);
+ }
+ vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
}
-static VkResult entry_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
- VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+VkResult gfxstream_vk_MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
+ VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
AEMU_SCOPED_TRACE("vkMapMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemory_VkResult_return = (VkResult)0;
- vkMapMemory_VkResult_return =
- vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkMapMemory_VkResult_return =
+ vkEnc->vkMapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
+ offset, size, flags, ppData, true /* do lock */);
+ }
return vkMapMemory_VkResult_return;
}
-static void entry_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+void gfxstream_vk_UnmapMemory(VkDevice device, VkDeviceMemory memory) {
AEMU_SCOPED_TRACE("vkUnmapMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUnmapMemory(device, memory, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkUnmapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
+VkResult gfxstream_vk_FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
- vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(
- device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+ internal_pMemoryRanges[i] = pMemoryRanges[i];
+ /* VkMappedMemoryRange::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pMemoryRanges[i].memory);
+ internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
+ }
+ vkFlushMappedMemoryRanges_VkResult_return =
+ vkEnc->vkFlushMappedMemoryRanges(gfxstream_device->internal_object, memoryRangeCount,
+ internal_pMemoryRanges.data(), true /* do lock */);
+ }
return vkFlushMappedMemoryRanges_VkResult_return;
}
-static VkResult entry_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
+VkResult gfxstream_vk_InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
- vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
- device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+ internal_pMemoryRanges[i] = pMemoryRanges[i];
+ /* VkMappedMemoryRange::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pMemoryRanges[i].memory);
+ internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
+ }
+ vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
+ gfxstream_device->internal_object, memoryRangeCount, internal_pMemoryRanges.data(),
+ true /* do lock */);
+ }
return vkInvalidateMappedMemoryRanges_VkResult_return;
}
-static void entry_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes) {
+void gfxstream_vk_GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceMemoryCommitment(gfxstream_device->internal_object,
+ gfxstream_memory->internal_object,
+ pCommittedMemoryInBytes, true /* do lock */);
+ }
}
-static VkResult entry_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
- VkDeviceSize memoryOffset) {
+VkResult gfxstream_vk_BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindBufferMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindBufferMemory_VkResult_return =
- resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindBufferMemory_VkResult_return = resources->on_vkBindBufferMemory(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_buffer->internal_object,
+ gfxstream_memory->internal_object, memoryOffset);
+ }
return vkBindBufferMemory_VkResult_return;
}
-static VkResult entry_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
- VkDeviceSize memoryOffset) {
+VkResult gfxstream_vk_BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindImageMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindImageMemory_VkResult_return =
- resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindImageMemory_VkResult_return = resources->on_vkBindImageMemory(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_image->internal_object,
+ gfxstream_memory->internal_object, memoryOffset);
+ }
return vkBindImageMemory_VkResult_return;
}
-static void entry_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements) {
+void gfxstream_vk_GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetBufferMemoryRequirements(vkEnc, gfxstream_device->internal_object,
+ gfxstream_buffer->internal_object,
+ pMemoryRequirements);
+ }
}
-static void entry_vkGetImageMemoryRequirements(VkDevice device, VkImage image,
- VkMemoryRequirements* pMemoryRequirements) {
+void gfxstream_vk_GetImageMemoryRequirements(VkDevice device, VkImage image,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetImageMemoryRequirements(vkEnc, gfxstream_device->internal_object,
+ gfxstream_image->internal_object,
+ pMemoryRequirements);
+ }
}
-static void entry_vkGetImageSparseMemoryRequirements(
+void gfxstream_vk_GetImageSparseMemoryRequirements(
VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements(
+ gfxstream_device->internal_object, gfxstream_image->internal_object,
+ pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples,
- usage, tiling, pPropertyCount,
- pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(
+ gfxstream_physicalDevice->internal_object, format, type, samples, usage, tiling,
+ pPropertyCount, pProperties, true /* do lock */);
+ }
}
-static VkResult entry_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo, VkFence fence) {
+VkResult gfxstream_vk_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueBindSparse");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
- vkQueueBindSparse_VkResult_return =
- vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
+ std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
+ internal_VkBindSparseInfo_pBufferBinds;
+ std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
+ internal_VkBindSparseInfo_pImageOpaqueBinds;
+ std::vector<std::vector<VkSparseMemoryBind>>
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
+ std::vector<std::vector<VkSparseImageMemoryBind>>
+ internal_VkSparseImageMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfo[i] = pBindInfo[i];
+ /* VkBindSparseInfo::pWaitSemaphores */
+ internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
+ internal_pBindInfo[i].pWaitSemaphores =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].data();
+ internal_pBindInfo[i].waitSemaphoreCount =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].size();
+ /* VkBindSparseInfo::pBufferBinds */
+ internal_VkBindSparseInfo_pBufferBinds.push_back(
+ std::vector<VkSparseBufferMemoryBindInfo>());
+ internal_VkBindSparseInfo_pBufferBinds[i].reserve(
+ internal_pBindInfo[i].bufferBindCount);
+ memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
+ sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
+ internal_VkBindSparseInfo_pBufferBinds[i][j] =
+ internal_pBindInfo[i].pBufferBinds[j];
+ /* VkSparseBufferMemoryBindInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ /* VkSparseBufferMemoryBindInfo::pBinds */
+ internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
+ ++k) {
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
+ /* VkBindSparseInfo::pImageOpaqueBinds */
+ internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
+ std::vector<VkSparseImageOpaqueMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
+ sizeof(VkSparseImageOpaqueMemoryBindInfo) *
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
+ internal_pBindInfo[i].pImageOpaqueBinds[j];
+ /* VkSparseImageOpaqueMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ for (uint32_t l = 0;
+ l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageOpaqueBinds =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
+ /* VkBindSparseInfo::pImageBinds */
+ internal_VkBindSparseInfo_pImageBinds.push_back(
+ std::vector<VkSparseImageMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
+ memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
+ sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
+ /* VkSparseImageMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageMemoryBindInfo::pBinds */
+ internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseImageMemoryBind>());
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseImageMemoryBind) *
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
+ ++m) {
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
+ /* VkSparseImageMemoryBind::memory */
+ if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
+ /* VkBindSparseInfo::pSignalSemaphores */
+ internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pSignalSemaphores[i] =
+ transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
+ internal_pBindInfo[i].signalSemaphoreCount);
+ internal_pBindInfo[i].pSignalSemaphores =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].data();
+ internal_pBindInfo[i].signalSemaphoreCount =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].size();
+ }
+ vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(
+ gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
return vkQueueBindSparse_VkResult_return;
}
-static VkResult entry_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+VkResult gfxstream_vk_CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
AEMU_SCOPED_TRACE("vkCreateFence");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFence_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateFence_VkResult_return =
- resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_fence* gfxstream_pFence = (gfxstream_vk_fence*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_fence), VK_OBJECT_TYPE_FENCE);
+ vkCreateFence_VkResult_return = gfxstream_pFence ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateFence_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateFence_VkResult_return = resources->on_vkCreateFence(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pFence->internal_object);
+ }
+ *pFence = gfxstream_vk_fence_to_handle(gfxstream_pFence);
return vkCreateFence_VkResult_return;
}
-static void entry_vkDestroyFence(VkDevice device, VkFence fence,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyFence(VkDevice device, VkFence fence,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFence");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyFence(device, fence, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == fence) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyFence(gfxstream_device->internal_object,
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_fence);
}
-static VkResult entry_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+VkResult gfxstream_vk_ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
AEMU_SCOPED_TRACE("vkResetFences");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetFences_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkResetFences_VkResult_return =
- resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFence> internal_pFences(fenceCount);
+ for (uint32_t i = 0; i < fenceCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
+ internal_pFences[i] = gfxstream_pFences->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkResetFences_VkResult_return =
+ resources->on_vkResetFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ fenceCount, internal_pFences.data());
+ }
return vkResetFences_VkResult_return;
}
-static VkResult entry_vkGetFenceStatus(VkDevice device, VkFence fence) {
+VkResult gfxstream_vk_GetFenceStatus(VkDevice device, VkFence fence) {
AEMU_SCOPED_TRACE("vkGetFenceStatus");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
- vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetFenceStatus_VkResult_return =
+ vkEnc->vkGetFenceStatus(gfxstream_device->internal_object,
+ gfxstream_fence->internal_object, true /* do lock */);
+ }
return vkGetFenceStatus_VkResult_return;
}
-static VkResult entry_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
- VkBool32 waitAll, uint64_t timeout) {
+VkResult gfxstream_vk_WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+ VkBool32 waitAll, uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitForFences");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitForFences_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(
- vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFence> internal_pFences(fenceCount);
+ for (uint32_t i = 0; i < fenceCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
+ internal_pFences[i] = gfxstream_pFences->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkWaitForFences_VkResult_return =
+ resources->on_vkWaitForFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ fenceCount, internal_pFences.data(), waitAll, timeout);
+ }
return vkWaitForFences_VkResult_return;
}
-static VkResult entry_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSemaphore* pSemaphore) {
+VkResult gfxstream_vk_CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore) {
AEMU_SCOPED_TRACE("vkCreateSemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_semaphore* gfxstream_pSemaphore = (gfxstream_vk_semaphore*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_semaphore),
+ VK_OBJECT_TYPE_SEMAPHORE);
+ vkCreateSemaphore_VkResult_return =
+ gfxstream_pSemaphore ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateSemaphore_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pSemaphore->internal_object);
+ }
+ *pSemaphore = gfxstream_vk_semaphore_to_handle(gfxstream_pSemaphore);
return vkCreateSemaphore_VkResult_return;
}
-static void entry_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySemaphore(VkDevice device, VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator);
+ if (VK_NULL_HANDLE == semaphore) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroySemaphore(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
+ pAllocator);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_semaphore);
}
-static VkResult entry_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+VkResult gfxstream_vk_CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
AEMU_SCOPED_TRACE("vkCreateEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateEvent_VkResult_return = (VkResult)0;
- vkCreateEvent_VkResult_return =
- vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_event* gfxstream_pEvent = (gfxstream_vk_event*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_event), VK_OBJECT_TYPE_EVENT);
+ vkCreateEvent_VkResult_return = gfxstream_pEvent ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateEvent_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateEvent_VkResult_return =
+ vkEnc->vkCreateEvent(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pEvent->internal_object, true /* do lock */);
+ }
+ *pEvent = gfxstream_vk_event_to_handle(gfxstream_pEvent);
return vkCreateEvent_VkResult_return;
}
-static void entry_vkDestroyEvent(VkDevice device, VkEvent event,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyEvent(VkDevice device, VkEvent event,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyEvent(device, event, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == event) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyEvent(gfxstream_device->internal_object,
+ gfxstream_event ? gfxstream_event->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_event);
}
-static VkResult entry_vkGetEventStatus(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_GetEventStatus(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkGetEventStatus");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
- vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetEventStatus_VkResult_return =
+ vkEnc->vkGetEventStatus(gfxstream_device->internal_object,
+ gfxstream_event->internal_object, true /* do lock */);
+ }
return vkGetEventStatus_VkResult_return;
}
-static VkResult entry_vkSetEvent(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_SetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkSetEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetEvent_VkResult_return = (VkResult)0;
- vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkSetEvent_VkResult_return =
+ vkEnc->vkSetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
+ true /* do lock */);
+ }
return vkSetEvent_VkResult_return;
}
-static VkResult entry_vkResetEvent(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_ResetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkResetEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetEvent_VkResult_return = (VkResult)0;
- vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkResetEvent_VkResult_return =
+ vkEnc->vkResetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
+ true /* do lock */);
+ }
return vkResetEvent_VkResult_return;
}
-static VkResult entry_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkQueryPool* pQueryPool) {
+VkResult gfxstream_vk_CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool) {
AEMU_SCOPED_TRACE("vkCreateQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_query_pool* gfxstream_pQueryPool =
+ (struct gfxstream_vk_query_pool*)vk_query_pool_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
+ sizeof(struct gfxstream_vk_query_pool));
vkCreateQueryPool_VkResult_return =
- vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, true /* do lock */);
+ gfxstream_pQueryPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateQueryPool_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateQueryPool_VkResult_return =
+ vkEnc->vkCreateQueryPool(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pQueryPool->internal_object, true /* do lock */);
+ }
+ *pQueryPool = gfxstream_vk_query_pool_to_handle(gfxstream_pQueryPool);
return vkCreateQueryPool_VkResult_return;
}
-static void entry_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == queryPool) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyQueryPool(
+ gfxstream_device->internal_object,
+ gfxstream_queryPool ? gfxstream_queryPool->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_query_pool_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_queryPool->vk);
}
-static VkResult entry_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount,
- size_t dataSize, void* pData, VkDeviceSize stride,
- VkQueryResultFlags flags) {
+VkResult gfxstream_vk_GetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
+ void* pData, VkDeviceSize stride,
+ VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
- vkGetQueryPoolResults_VkResult_return =
- vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData,
- stride, flags, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(
+ gfxstream_device->internal_object, gfxstream_queryPool->internal_object, firstQuery,
+ queryCount, dataSize, pData, stride, flags, true /* do lock */);
+ }
return vkGetQueryPoolResults_VkResult_return;
}
-static VkResult entry_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+VkResult gfxstream_vk_CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
AEMU_SCOPED_TRACE("vkCreateBuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateBuffer_VkResult_return =
- resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
+ vkCreateBuffer_VkResult_return = gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateBuffer_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateBuffer_VkResult_return = resources->on_vkCreateBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pBuffer->internal_object);
+ }
+ *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
return vkCreateBuffer_VkResult_return;
}
-static void entry_vkDestroyBuffer(VkDevice device, VkBuffer buffer,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyBuffer(VkDevice device, VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator);
+ if (VK_NULL_HANDLE == buffer) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyBuffer(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_buffer ? gfxstream_buffer->internal_object : VK_NULL_HANDLE, pAllocator);
+ }
+ vk_buffer_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_buffer->vk);
}
-static VkResult entry_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferView* pView) {
+VkResult gfxstream_vk_CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView) {
AEMU_SCOPED_TRACE("vkCreateBufferView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
- vkCreateBufferView_VkResult_return =
- vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_buffer_view* gfxstream_pView =
+ (struct gfxstream_vk_buffer_view*)vk_buffer_view_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
+ sizeof(struct gfxstream_vk_buffer_view));
+ vkCreateBufferView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateBufferView_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferViewCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkBufferViewCreateInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pCreateInfo[i].buffer);
+ internal_pCreateInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pView->internal_object, true /* do lock */);
+ }
+ *pView = gfxstream_vk_buffer_view_to_handle(gfxstream_pView);
return vkCreateBufferView_VkResult_return;
}
-static void entry_vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyBufferView(VkDevice device, VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBufferView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyBufferView(device, bufferView, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == bufferView) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_bufferView, bufferView);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyBufferView(
+ gfxstream_device->internal_object,
+ gfxstream_bufferView ? gfxstream_bufferView->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_buffer_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_bufferView->vk);
}
-static VkResult entry_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+VkResult gfxstream_vk_CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
AEMU_SCOPED_TRACE("vkCreateImage");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImage_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateImage_VkResult_return =
- resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
+ vkCreateImage_VkResult_return = gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateImage_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateImage_VkResult_return = resources->on_vkCreateImage(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pImage->internal_object);
+ }
+ *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
return vkCreateImage_VkResult_return;
}
-static void entry_vkDestroyImage(VkDevice device, VkImage image,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyImage(VkDevice device, VkImage image,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImage");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyImage(vkEnc, device, image, pAllocator);
+ if (VK_NULL_HANDLE == image) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyImage(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_image ? gfxstream_image->internal_object : VK_NULL_HANDLE, pAllocator);
+ }
+ vk_image_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_image->vk);
}
-static void entry_vkGetImageSubresourceLayout(VkDevice device, VkImage image,
- const VkImageSubresource* pSubresource,
- VkSubresourceLayout* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout(VkDevice device, VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSubresourceLayout(gfxstream_device->internal_object,
+ gfxstream_image->internal_object, pSubresource, pLayout,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImageView* pView) {
+VkResult gfxstream_vk_CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
AEMU_SCOPED_TRACE("vkCreateImageView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageView_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateImageView_VkResult_return =
- resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_image_view* gfxstream_pView =
+ (struct gfxstream_vk_image_view*)vk_image_view_create(
+ (vk_device*)gfxstream_device, false /* driver_internal */, pCreateInfo, pAllocator,
+ sizeof(struct gfxstream_vk_image_view));
+ vkCreateImageView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateImageView_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageViewCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkImageViewCreateInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pCreateInfo[i].image);
+ internal_pCreateInfo[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateImageView_VkResult_return = resources->on_vkCreateImageView(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pCreateInfo.data(),
+ pAllocator, &gfxstream_pView->internal_object);
+ }
+ *pView = gfxstream_vk_image_view_to_handle(gfxstream_pView);
return vkCreateImageView_VkResult_return;
}
-static void entry_vkDestroyImageView(VkDevice device, VkImageView imageView,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyImageView(VkDevice device, VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImageView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyImageView(device, imageView, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == imageView) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView, imageView);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyImageView(
+ gfxstream_device->internal_object,
+ gfxstream_imageView ? gfxstream_imageView->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_image_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_imageView->vk);
}
-static VkResult entry_vkCreateShaderModule(VkDevice device,
- const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkShaderModule* pShaderModule) {
+VkResult gfxstream_vk_CreateShaderModule(VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule) {
AEMU_SCOPED_TRACE("vkCreateShaderModule");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
- vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
- device, pCreateInfo, pAllocator, pShaderModule, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_shader_module* gfxstream_pShaderModule =
+ (gfxstream_vk_shader_module*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_shader_module),
+ VK_OBJECT_TYPE_SHADER_MODULE);
+ vkCreateShaderModule_VkResult_return =
+ gfxstream_pShaderModule ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateShaderModule_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pShaderModule->internal_object, true /* do lock */);
+ }
+ *pShaderModule = gfxstream_vk_shader_module_to_handle(gfxstream_pShaderModule);
return vkCreateShaderModule_VkResult_return;
}
-static void entry_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyShaderModule");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == shaderModule) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_shaderModule, shaderModule);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyShaderModule(
+ gfxstream_device->internal_object,
+ gfxstream_shaderModule ? gfxstream_shaderModule->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_shaderModule);
}
-static VkResult entry_vkCreatePipelineCache(VkDevice device,
- const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineCache* pPipelineCache) {
+VkResult gfxstream_vk_CreatePipelineCache(VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache) {
AEMU_SCOPED_TRACE("vkCreatePipelineCache");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
- vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
- device, pCreateInfo, pAllocator, pPipelineCache, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_pipeline_cache* gfxstream_pPipelineCache =
+ (gfxstream_vk_pipeline_cache*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_pipeline_cache),
+ VK_OBJECT_TYPE_PIPELINE_CACHE);
+ vkCreatePipelineCache_VkResult_return =
+ gfxstream_pPipelineCache ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreatePipelineCache_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pPipelineCache->internal_object, true /* do lock */);
+ }
+ *pPipelineCache = gfxstream_vk_pipeline_cache_to_handle(gfxstream_pPipelineCache);
return vkCreatePipelineCache_VkResult_return;
}
-static void entry_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == pipelineCache) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPipelineCache(
+ gfxstream_device->internal_object,
+ gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineCache);
}
-static VkResult entry_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
- size_t* pDataSize, void* pData) {
+VkResult gfxstream_vk_GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+ size_t* pDataSize, void* pData) {
AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
- vkGetPipelineCacheData_VkResult_return =
- vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(
+ gfxstream_device->internal_object, gfxstream_pipelineCache->internal_object, pDataSize,
+ pData, true /* do lock */);
+ }
return vkGetPipelineCacheData_VkResult_return;
}
-static VkResult entry_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
- uint32_t srcCacheCount,
- const VkPipelineCache* pSrcCaches) {
+VkResult gfxstream_vk_MergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches) {
AEMU_SCOPED_TRACE("vkMergePipelineCaches");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
- vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
- device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_dstCache, dstCache);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineCache> internal_pSrcCaches(srcCacheCount);
+ for (uint32_t i = 0; i < srcCacheCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pSrcCaches, pSrcCaches[i]);
+ internal_pSrcCaches[i] = gfxstream_pSrcCaches->internal_object;
+ }
+ vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
+ gfxstream_device->internal_object, gfxstream_dstCache->internal_object, srcCacheCount,
+ internal_pSrcCaches.data(), true /* do lock */);
+ }
return vkMergePipelineCaches_VkResult_return;
}
-static VkResult entry_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines) {
+VkResult gfxstream_vk_CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
- vkEnc, VK_SUCCESS, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
- pPipelines);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+ struct gfxstream_vk_pipeline* gfxstream_pPipelines = (gfxstream_vk_pipeline*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_pipeline), VK_OBJECT_TYPE_PIPELINE);
+ vkCreateGraphicsPipelines_VkResult_return =
+ gfxstream_pPipelines ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateGraphicsPipelines_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkGraphicsPipelineCreateInfo> internal_pCreateInfos(createInfoCount);
+ std::vector<std::vector<VkPipelineShaderStageCreateInfo>>
+ internal_VkGraphicsPipelineCreateInfo_pStages;
+ for (uint32_t i = 0; i < createInfoCount; ++i) {
+ internal_pCreateInfos[i] = pCreateInfos[i];
+ /* VkGraphicsPipelineCreateInfo::pStages */
+ internal_VkGraphicsPipelineCreateInfo_pStages.push_back(
+ std::vector<VkPipelineShaderStageCreateInfo>());
+ internal_VkGraphicsPipelineCreateInfo_pStages[i].reserve(
+ internal_pCreateInfos[i].stageCount);
+ memset(&internal_VkGraphicsPipelineCreateInfo_pStages[i][0], 0,
+ sizeof(VkPipelineShaderStageCreateInfo) * internal_pCreateInfos[i].stageCount);
+ for (uint32_t j = 0; j < internal_pCreateInfos[i].stageCount; ++j) {
+ if (internal_pCreateInfos[i].pStages) {
+ internal_VkGraphicsPipelineCreateInfo_pStages[i][j] =
+ internal_pCreateInfos[i].pStages[j];
+ /* VkPipelineShaderStageCreateInfo::module */
+ if (internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module) {
+ VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_module,
+ internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module);
+ internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module =
+ gfxstream_module->internal_object;
+ }
+ }
+ }
+ internal_pCreateInfos[i].pStages =
+ internal_VkGraphicsPipelineCreateInfo_pStages[i].data();
+ /* VkGraphicsPipelineCreateInfo::layout */
+ if (internal_pCreateInfos[i].layout) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout,
+ internal_pCreateInfos[i].layout);
+ internal_pCreateInfos[i].layout = gfxstream_layout->internal_object;
+ }
+ /* VkGraphicsPipelineCreateInfo::renderPass */
+ if (internal_pCreateInfos[i].renderPass) {
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pCreateInfos[i].renderPass);
+ internal_pCreateInfos[i].renderPass = gfxstream_renderPass->internal_object;
+ }
+ /* VkGraphicsPipelineCreateInfo::basePipelineHandle */
+ if (internal_pCreateInfos[i].basePipelineHandle) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_basePipelineHandle,
+ internal_pCreateInfos[i].basePipelineHandle);
+ internal_pCreateInfos[i].basePipelineHandle =
+ gfxstream_basePipelineHandle->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
+ createInfoCount, internal_pCreateInfos.data(), pAllocator,
+ &gfxstream_pPipelines->internal_object);
+ }
+ *pPipelines = gfxstream_vk_pipeline_to_handle(gfxstream_pPipelines);
return vkCreateGraphicsPipelines_VkResult_return;
}
-static VkResult entry_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines) {
- AEMU_SCOPED_TRACE("vkCreateComputePipelines");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
- vkCreateComputePipelines_VkResult_return =
- vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos,
- pAllocator, pPipelines, true /* do lock */);
- return vkCreateComputePipelines_VkResult_return;
-}
-static void entry_vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipeline(VkDevice device, VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipeline");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipeline(device, pipeline, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == pipeline) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPipeline(
+ gfxstream_device->internal_object,
+ gfxstream_pipeline ? gfxstream_pipeline->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipeline);
}
-static VkResult entry_vkCreatePipelineLayout(VkDevice device,
- const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineLayout* pPipelineLayout) {
+VkResult gfxstream_vk_CreatePipelineLayout(VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout) {
AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
- vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
- device, pCreateInfo, pAllocator, pPipelineLayout, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_pipeline_layout* gfxstream_pPipelineLayout =
+ (gfxstream_vk_pipeline_layout*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_pipeline_layout),
+ VK_OBJECT_TYPE_PIPELINE_LAYOUT);
+ vkCreatePipelineLayout_VkResult_return =
+ gfxstream_pPipelineLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreatePipelineLayout_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineLayoutCreateInfo> internal_pCreateInfo(1);
+ std::vector<std::vector<VkDescriptorSetLayout>>
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkPipelineLayoutCreateInfo::pSetLayouts */
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts.push_back(
+ std::vector<VkDescriptorSetLayout>());
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].reserve(
+ internal_pCreateInfo[i].setLayoutCount);
+ memset(&internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][0], 0,
+ sizeof(VkDescriptorSetLayout) * internal_pCreateInfo[i].setLayoutCount);
+ for (uint32_t j = 0; j < internal_pCreateInfo[i].setLayoutCount; ++j) {
+ if (internal_pCreateInfo[i].pSetLayouts) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+ internal_pCreateInfo[i].pSetLayouts[j]);
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][j] =
+ gfxstream_pSetLayouts->internal_object;
+ }
+ }
+ internal_pCreateInfo[i].pSetLayouts =
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].data();
+ }
+ vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pPipelineLayout->internal_object, true /* do lock */);
+ }
+ *pPipelineLayout = gfxstream_vk_pipeline_layout_to_handle(gfxstream_pPipelineLayout);
return vkCreatePipelineLayout_VkResult_return;
}
-static void entry_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == pipelineLayout) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout, pipelineLayout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPipelineLayout(
+ gfxstream_device->internal_object,
+ gfxstream_pipelineLayout ? gfxstream_pipelineLayout->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineLayout);
}
-static VkResult entry_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSampler* pSampler) {
+VkResult gfxstream_vk_CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
AEMU_SCOPED_TRACE("vkCreateSampler");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSampler_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSampler_VkResult_return =
- resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSampler_VkResult_return =
+ resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ pCreateInfo, pAllocator, pSampler);
+ }
return vkCreateSampler_VkResult_return;
}
-static void entry_vkDestroySampler(VkDevice device, VkSampler sampler,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySampler(VkDevice device, VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySampler");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroySampler(device, sampler, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == sampler) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroySampler(gfxstream_device->internal_object, sampler, pAllocator,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkCreateDescriptorSetLayout(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+VkResult gfxstream_vk_CreateDescriptorSetLayout(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout) {
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_set_layout* gfxstream_pSetLayout =
+ (gfxstream_vk_descriptor_set_layout*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_set_layout),
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
+ vkCreateDescriptorSetLayout_VkResult_return =
+ gfxstream_pSetLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorSetLayout_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pSetLayout->internal_object);
+ }
+ *pSetLayout = gfxstream_vk_descriptor_set_layout_to_handle(gfxstream_pSetLayout);
return vkCreateDescriptorSetLayout_VkResult_return;
}
-static void entry_vkDestroyDescriptorSetLayout(VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyDescriptorSetLayout(VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyDescriptorSetLayout(vkEnc, device, descriptorSetLayout, pAllocator);
+ if (VK_NULL_HANDLE == descriptorSetLayout) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+ descriptorSetLayout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyDescriptorSetLayout(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_descriptorSetLayout ? gfxstream_descriptorSetLayout->internal_object
+ : VK_NULL_HANDLE,
+ pAllocator);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorSetLayout);
}
-static VkResult entry_vkCreateDescriptorPool(VkDevice device,
- const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorPool* pDescriptorPool) {
+VkResult gfxstream_vk_CreateDescriptorPool(VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool) {
AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_pool* gfxstream_pDescriptorPool =
+ (gfxstream_vk_descriptor_pool*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_descriptor_pool),
+ VK_OBJECT_TYPE_DESCRIPTOR_POOL);
+ vkCreateDescriptorPool_VkResult_return =
+ gfxstream_pDescriptorPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorPool_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pDescriptorPool->internal_object);
+ }
+ *pDescriptorPool = gfxstream_vk_descriptor_pool_to_handle(gfxstream_pDescriptorPool);
return vkCreateDescriptorPool_VkResult_return;
}
-static void entry_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyDescriptorPool(vkEnc, device, descriptorPool, pAllocator);
+ if (VK_NULL_HANDLE == descriptorPool) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyDescriptorPool(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_descriptorPool ? gfxstream_descriptorPool->internal_object : VK_NULL_HANDLE,
+ pAllocator);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorPool);
}
-static VkResult entry_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
- VkDescriptorPoolResetFlags flags) {
+VkResult gfxstream_vk_ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetDescriptorPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkResetDescriptorPool_VkResult_return =
- resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkResetDescriptorPool_VkResult_return = resources->on_vkResetDescriptorPool(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ gfxstream_descriptorPool->internal_object, flags);
+ }
return vkResetDescriptorPool_VkResult_return;
}
-static VkResult entry_vkAllocateDescriptorSets(VkDevice device,
- const VkDescriptorSetAllocateInfo* pAllocateInfo,
- VkDescriptorSet* pDescriptorSets) {
+VkResult gfxstream_vk_AllocateDescriptorSets(VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
- vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorSetAllocateInfo> internal_pAllocateInfo(1);
+ std::vector<std::vector<VkDescriptorSetLayout>>
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pAllocateInfo[i] = pAllocateInfo[i];
+ /* VkDescriptorSetAllocateInfo::descriptorPool */
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool,
+ internal_pAllocateInfo[i].descriptorPool);
+ internal_pAllocateInfo[i].descriptorPool = gfxstream_descriptorPool->internal_object;
+ /* VkDescriptorSetAllocateInfo::pSetLayouts */
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts.push_back(
+ std::vector<VkDescriptorSetLayout>());
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].reserve(
+ internal_pAllocateInfo[i].descriptorSetCount);
+ memset(&internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][0], 0,
+ sizeof(VkDescriptorSetLayout) * internal_pAllocateInfo[i].descriptorSetCount);
+ for (uint32_t j = 0; j < internal_pAllocateInfo[i].descriptorSetCount; ++j) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+ internal_pAllocateInfo[i].pSetLayouts[j]);
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][j] =
+ gfxstream_pSetLayouts->internal_object;
+ }
+ internal_pAllocateInfo[i].pSetLayouts =
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].data();
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pAllocateInfo.data(),
+ pDescriptorSets);
+ }
return vkAllocateDescriptorSets_VkResult_return;
}
-static VkResult entry_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets) {
+VkResult gfxstream_vk_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
- vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ if (VK_NULL_HANDLE == pDescriptorSets) {
+ return vkFreeDescriptorSets_VkResult_return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ gfxstream_descriptorPool->internal_object, descriptorSetCount, pDescriptorSets);
+ }
return vkFreeDescriptorSets_VkResult_return;
}
-static void entry_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t descriptorCopyCount,
- const VkCopyDescriptorSet* pDescriptorCopies) {
+void gfxstream_vk_UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSets");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites,
- descriptorCopyCount, pDescriptorCopies);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkWriteDescriptorSet> internal_pDescriptorWrites(descriptorWriteCount);
+ std::vector<std::vector<VkDescriptorImageInfo>> internal_VkWriteDescriptorSet_pImageInfo;
+ std::vector<std::vector<VkDescriptorBufferInfo>> internal_VkWriteDescriptorSet_pBufferInfo;
+ std::vector<std::vector<VkBufferView>> internal_VkWriteDescriptorSet_pTexelBufferView;
+ for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+ internal_pDescriptorWrites[i] = pDescriptorWrites[i];
+ /* VkWriteDescriptorSet::pImageInfo */
+ internal_VkWriteDescriptorSet_pImageInfo.push_back(
+ std::vector<VkDescriptorImageInfo>());
+ internal_VkWriteDescriptorSet_pImageInfo[i].reserve(
+ internal_pDescriptorWrites[i].descriptorCount);
+ memset(&internal_VkWriteDescriptorSet_pImageInfo[i][0], 0,
+ sizeof(VkDescriptorImageInfo) * internal_pDescriptorWrites[i].descriptorCount);
+ for (uint32_t j = 0; j < internal_pDescriptorWrites[i].descriptorCount; ++j) {
+ if (internal_pDescriptorWrites[i].pImageInfo) {
+ internal_VkWriteDescriptorSet_pImageInfo[i][j] =
+ internal_pDescriptorWrites[i].pImageInfo[j];
+ /* VkDescriptorImageInfo::imageView */
+ if (internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView);
+ internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ }
+ }
+ internal_pDescriptorWrites[i].pImageInfo =
+ internal_VkWriteDescriptorSet_pImageInfo[i].data();
+ /* VkWriteDescriptorSet::pBufferInfo */
+ internal_VkWriteDescriptorSet_pBufferInfo.push_back(
+ std::vector<VkDescriptorBufferInfo>());
+ internal_VkWriteDescriptorSet_pBufferInfo[i].reserve(
+ internal_pDescriptorWrites[i].descriptorCount);
+ memset(&internal_VkWriteDescriptorSet_pBufferInfo[i][0], 0,
+ sizeof(VkDescriptorBufferInfo) * internal_pDescriptorWrites[i].descriptorCount);
+ for (uint32_t j = 0; j < internal_pDescriptorWrites[i].descriptorCount; ++j) {
+ if (internal_pDescriptorWrites[i].pBufferInfo) {
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j] =
+ internal_pDescriptorWrites[i].pBufferInfo[j];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer);
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ internal_pDescriptorWrites[i].pBufferInfo =
+ internal_VkWriteDescriptorSet_pBufferInfo[i].data();
+ /* VkWriteDescriptorSet::pTexelBufferView */
+ internal_VkWriteDescriptorSet_pTexelBufferView.push_back(std::vector<VkBufferView>());
+ internal_VkWriteDescriptorSet_pTexelBufferView[i].reserve(
+ internal_pDescriptorWrites[i].descriptorCount);
+ memset(&internal_VkWriteDescriptorSet_pTexelBufferView[i][0], 0,
+ sizeof(VkBufferView) * internal_pDescriptorWrites[i].descriptorCount);
+ for (uint32_t j = 0; j < internal_pDescriptorWrites[i].descriptorCount; ++j) {
+ if (internal_pDescriptorWrites[i].pTexelBufferView) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pTexelBufferView,
+ internal_pDescriptorWrites[i].pTexelBufferView[j]);
+ internal_VkWriteDescriptorSet_pTexelBufferView[i][j] =
+ gfxstream_pTexelBufferView->internal_object;
+ }
+ }
+ internal_pDescriptorWrites[i].pTexelBufferView =
+ internal_VkWriteDescriptorSet_pTexelBufferView[i].data();
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkUpdateDescriptorSets(
+ vkEnc, gfxstream_device->internal_object, descriptorWriteCount,
+ internal_pDescriptorWrites.data(), descriptorCopyCount, pDescriptorCopies);
+ }
}
-static VkResult entry_vkCreateFramebuffer(VkDevice device,
- const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFramebuffer* pFramebuffer) {
+VkResult gfxstream_vk_CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer) {
AEMU_SCOPED_TRACE("vkCreateFramebuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
- vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
- device, pCreateInfo, pAllocator, pFramebuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_framebuffer* gfxstream_pFramebuffer =
+ (gfxstream_vk_framebuffer*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_framebuffer),
+ VK_OBJECT_TYPE_FRAMEBUFFER);
+ vkCreateFramebuffer_VkResult_return =
+ gfxstream_pFramebuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateFramebuffer_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFramebufferCreateInfo> internal_pCreateInfo(1);
+ std::vector<std::vector<VkImageView>> internal_VkFramebufferCreateInfo_pAttachments;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkFramebufferCreateInfo::renderPass */
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pCreateInfo[i].renderPass);
+ internal_pCreateInfo[i].renderPass = gfxstream_renderPass->internal_object;
+ /* VkFramebufferCreateInfo::pAttachments */
+ internal_VkFramebufferCreateInfo_pAttachments.push_back(std::vector<VkImageView>());
+ internal_VkFramebufferCreateInfo_pAttachments[i].reserve(
+ internal_pCreateInfo[i].attachmentCount);
+ memset(&internal_VkFramebufferCreateInfo_pAttachments[i][0], 0,
+ sizeof(VkImageView) * internal_pCreateInfo[i].attachmentCount);
+ for (uint32_t j = 0; j < internal_pCreateInfo[i].attachmentCount; ++j) {
+ if (internal_pCreateInfo[i].pAttachments) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_pAttachments,
+ internal_pCreateInfo[i].pAttachments[j]);
+ internal_VkFramebufferCreateInfo_pAttachments[i][j] =
+ gfxstream_pAttachments->internal_object;
+ }
+ }
+ internal_pCreateInfo[i].pAttachments =
+ internal_VkFramebufferCreateInfo_pAttachments[i].data();
+ }
+ vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pFramebuffer->internal_object, true /* do lock */);
+ }
+ *pFramebuffer = gfxstream_vk_framebuffer_to_handle(gfxstream_pFramebuffer);
return vkCreateFramebuffer_VkResult_return;
}
-static void entry_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == framebuffer) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer, framebuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyFramebuffer(
+ gfxstream_device->internal_object,
+ gfxstream_framebuffer ? gfxstream_framebuffer->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_framebuffer);
}
-static VkResult entry_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
+VkResult gfxstream_vk_CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+ (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_render_pass),
+ VK_OBJECT_TYPE_RENDER_PASS);
vkCreateRenderPass_VkResult_return =
- vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateRenderPass_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateRenderPass_VkResult_return =
+ vkEnc->vkCreateRenderPass(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pRenderPass->internal_object, true /* do lock */);
+ }
+ *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
return vkCreateRenderPass_VkResult_return;
}
-static void entry_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyRenderPass");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == renderPass) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyRenderPass(
+ gfxstream_device->internal_object,
+ gfxstream_renderPass ? gfxstream_renderPass->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_renderPass);
}
-static void entry_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
- VkExtent2D* pGranularity) {
+void gfxstream_vk_GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+ VkExtent2D* pGranularity) {
AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity, true /* do lock */);
-}
-static VkResult entry_vkCreateCommandPool(VkDevice device,
- const VkCommandPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCommandPool* pCommandPool) {
- AEMU_SCOPED_TRACE("vkCreateCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
- vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(
- device, pCreateInfo, pAllocator, pCommandPool, true /* do lock */);
- return vkCreateCommandPool_VkResult_return;
-}
-static void entry_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolResetFlags flags) {
- AEMU_SCOPED_TRACE("vkResetCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
- vkResetCommandPool_VkResult_return =
- vkEnc->vkResetCommandPool(device, commandPool, flags, true /* do lock */);
- if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetRenderAreaGranularity(gfxstream_device->internal_object,
+ gfxstream_renderPass->internal_object, pGranularity,
+ true /* do lock */);
}
- return vkResetCommandPool_VkResult_return;
}
-static VkResult entry_vkAllocateCommandBuffers(VkDevice device,
- const VkCommandBufferAllocateInfo* pAllocateInfo,
- VkCommandBuffer* pCommandBuffers) {
- AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkAllocateCommandBuffers_VkResult_return = resources->on_vkAllocateCommandBuffers(
- vkEnc, VK_SUCCESS, device, pAllocateInfo, pCommandBuffers);
- if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->addToCommandPool(
- pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
- }
- return vkAllocateCommandBuffers_VkResult_return;
-}
-static void entry_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers) {
- AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers,
- true /* do lock */);
-}
-static VkResult entry_vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo) {
+VkResult gfxstream_vk_BeginCommandBuffer(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo) {
AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBeginCommandBuffer_VkResult_return =
- resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
+ std::vector<VkCommandBufferInheritanceInfo>
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBeginInfo[i] = pBeginInfo[i];
+ /* VkCommandBufferBeginInfo::pInheritanceInfo */
+ if (internal_pBeginInfo[i].pInheritanceInfo) {
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
+ internal_pBeginInfo[i].pInheritanceInfo[0];
+ /* VkCommandBufferInheritanceInfo::renderPass */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
+ gfxstream_renderPass->internal_object;
+ }
+ /* VkCommandBufferInheritanceInfo::framebuffer */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
+ gfxstream_framebuffer->internal_object;
+ }
+ internal_pBeginInfo[i].pInheritanceInfo =
+ &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object,
+ internal_pBeginInfo.data());
+ }
return vkBeginCommandBuffer_VkResult_return;
}
-static VkResult entry_vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+VkResult gfxstream_vk_EndCommandBuffer(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkEndCommandBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEndCommandBuffer_VkResult_return =
- resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object);
+ }
return vkEndCommandBuffer_VkResult_return;
}
-static VkResult entry_vkResetCommandBuffer(VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags) {
+VkResult gfxstream_vk_ResetCommandBuffer(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkResetCommandBuffer_VkResult_return =
- resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object, flags);
+ }
return vkResetCommandBuffer_VkResult_return;
}
-static void entry_vkCmdBindPipeline(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+void gfxstream_vk_CmdBindPipeline(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
AEMU_SCOPED_TRACE("vkCmdBindPipeline");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindPipeline(gfxstream_commandBuffer->internal_object, pipelineBindPoint,
+ gfxstream_pipeline->internal_object, true /* do lock */);
+ }
}
-static void entry_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
- uint32_t viewportCount, const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount, const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewport");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetViewport(gfxstream_commandBuffer->internal_object, firstViewport,
+ viewportCount, pViewports, true /* do lock */);
+ }
}
-static void entry_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
- uint32_t scissorCount, const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+ uint32_t scissorCount, const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissor");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetScissor(gfxstream_commandBuffer->internal_object, firstScissor, scissorCount,
+ pScissors, true /* do lock */);
+ }
}
-static void entry_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+void gfxstream_vk_CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetLineWidth(gfxstream_commandBuffer->internal_object, lineWidth,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
- float depthBiasClamp, float depthBiasSlopeFactor) {
+void gfxstream_vk_CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+ float depthBiasClamp, float depthBiasSlopeFactor) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp,
- depthBiasSlopeFactor, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBias(gfxstream_commandBuffer->internal_object, depthBiasConstantFactor,
+ depthBiasClamp, depthBiasSlopeFactor, true /* do lock */);
+ }
}
-static void entry_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
- const float blendConstants[4]) {
+void gfxstream_vk_CmdSetBlendConstants(VkCommandBuffer commandBuffer,
+ const float blendConstants[4]) {
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetBlendConstants(gfxstream_commandBuffer->internal_object, blendConstants,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
- float maxDepthBounds) {
+void gfxstream_vk_CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+ float maxDepthBounds) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBounds(gfxstream_commandBuffer->internal_object, minDepthBounds,
+ maxDepthBounds, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, uint32_t compareMask) {
+void gfxstream_vk_CmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask, uint32_t compareMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilCompareMask(gfxstream_commandBuffer->internal_object, faceMask,
+ compareMask, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, uint32_t writeMask) {
+void gfxstream_vk_CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t writeMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilWriteMask(gfxstream_commandBuffer->internal_object, faceMask,
+ writeMask, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, uint32_t reference) {
+void gfxstream_vk_CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t reference) {
AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilReference(gfxstream_commandBuffer->internal_object, faceMask,
+ reference, true /* do lock */);
+ }
}
-static void entry_vkCmdBindDescriptorSets(
+void gfxstream_vk_CmdBindDescriptorSets(
VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- auto resources = ResourceTracker::get();
- resources->on_vkCmdBindDescriptorSets(vkEnc, commandBuffer, pipelineBindPoint, layout, firstSet,
- descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
- pDynamicOffsets);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkCmdBindDescriptorSets(vkEnc, gfxstream_commandBuffer->internal_object,
+ pipelineBindPoint, gfxstream_layout->internal_object,
+ firstSet, descriptorSetCount, pDescriptorSets,
+ dynamicOffsetCount, pDynamicOffsets);
+ }
}
-static void entry_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkIndexType indexType) {
+void gfxstream_vk_CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkIndexType indexType) {
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType, true /* do lock */);
-}
-static void entry_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets) {
- AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- true /* do lock */);
-}
-static void entry_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
- uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
- AEMU_SCOPED_TRACE("vkCmdDraw");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance,
- true /* do lock */);
-}
-static void entry_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
- uint32_t instanceCount, uint32_t firstIndex,
- int32_t vertexOffset, uint32_t firstInstance) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset,
- firstInstance, true /* do lock */);
-}
-static void entry_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
-}
-static void entry_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, uint32_t drawCount,
- uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride,
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindIndexBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, indexType,
true /* do lock */);
+ }
}
-static void entry_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
- uint32_t groupCountY, uint32_t groupCountZ) {
- AEMU_SCOPED_TRACE("vkCmdDispatch");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ, true /* do lock */);
+void gfxstream_vk_CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets) {
+ AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ if (pBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBindVertexBuffers(gfxstream_commandBuffer->internal_object, firstBinding,
+ bindingCount, internal_pBuffers.data(), pOffsets,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset) {
- AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset, true /* do lock */);
+void gfxstream_vk_CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+ uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+ AEMU_SCOPED_TRACE("vkCmdDraw");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDraw(gfxstream_commandBuffer->internal_object, vertexCount, instanceCount,
+ firstVertex, firstInstance, true /* do lock */);
+ }
}
-static void entry_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
- VkBuffer dstBuffer, uint32_t regionCount,
- const VkBufferCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions,
- true /* do lock */);
+void gfxstream_vk_CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+ uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
+ uint32_t firstInstance) {
+ AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndexed(gfxstream_commandBuffer->internal_object, indexCount, instanceCount,
+ firstIndex, vertexOffset, firstInstance, true /* do lock */);
+ }
}
-static void entry_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
- regionCount, pRegions, true /* do lock */);
-}
-static void entry_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageBlit* pRegions, VkFilter filter) {
- AEMU_SCOPED_TRACE("vkCmdBlitImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
- regionCount, pRegions, filter, true /* do lock */);
-}
-static void entry_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
- VkImage dstImage, VkImageLayout dstImageLayout,
- uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
- pRegions, true /* do lock */);
-}
-static void entry_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkBuffer dstBuffer,
- uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
- pRegions, true /* do lock */);
-}
-static void entry_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, VkDeviceSize dataSize,
- const void* pData) {
- AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData,
- true /* do lock */);
-}
-static void entry_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
- AEMU_SCOPED_TRACE("vkCmdFillBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data, true /* do lock */);
-}
-static void entry_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
- VkImageLayout imageLayout, const VkClearColorValue* pColor,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges) {
- AEMU_SCOPED_TRACE("vkCmdClearColorImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges,
- true /* do lock */);
-}
-static void entry_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
- VkImageLayout imageLayout,
- const VkClearDepthStencilValue* pDepthStencil,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges) {
- AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
- pRanges, true /* do lock */);
-}
-static void entry_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
- const VkClearAttachment* pAttachments, uint32_t rectCount,
- const VkClearRect* pRects) {
- AEMU_SCOPED_TRACE("vkCmdClearAttachments");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects,
+void gfxstream_vk_CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndirect(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, drawCount, stride,
true /* do lock */);
+ }
}
-static void entry_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageResolve* pRegions) {
+void gfxstream_vk_CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndexedIndirect(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, drawCount,
+ stride, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ) {
+ AEMU_SCOPED_TRACE("vkCmdDispatch");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDispatch(gfxstream_commandBuffer->internal_object, groupCountX, groupCountY,
+ groupCountZ, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset) {
+ AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDispatchIndirect(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkBuffer dstBuffer, uint32_t regionCount,
+ const VkBufferCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyBuffer(
+ gfxstream_commandBuffer->internal_object, gfxstream_srcBuffer->internal_object,
+ gfxstream_dstBuffer->internal_object, regionCount, pRegions, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+ pRegions, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageBlit* pRegions, VkFilter filter) {
+ AEMU_SCOPED_TRACE("vkCmdBlitImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBlitImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+ pRegions, filter, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkImage dstImage, VkImageLayout dstImageLayout,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyBufferToImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcBuffer->internal_object,
+ gfxstream_dstImage->internal_object, dstImageLayout,
+ regionCount, pRegions, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyImageToBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstBuffer->internal_object, regionCount, pRegions,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize dataSize,
+ const void* pData) {
+ AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdUpdateBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_dstBuffer->internal_object, dstOffset, dataSize, pData,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+ AEMU_SCOPED_TRACE("vkCmdFillBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdFillBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_dstBuffer->internal_object, dstOffset, size, data,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout, const VkClearColorValue* pColor,
+ uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ AEMU_SCOPED_TRACE("vkCmdClearColorImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdClearColorImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_image->internal_object, imageLayout, pColor,
+ rangeCount, pRanges, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges) {
+ AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdClearDepthStencilImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_image->internal_object, imageLayout,
+ pDepthStencil, rangeCount, pRanges, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments, uint32_t rectCount,
+ const VkClearRect* pRects) {
+ AEMU_SCOPED_TRACE("vkCmdClearAttachments");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdClearAttachments(gfxstream_commandBuffer->internal_object, attachmentCount,
+ pAttachments, rectCount, pRects, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageResolve* pRegions) {
AEMU_SCOPED_TRACE("vkCmdResolveImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
- regionCount, pRegions, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResolveImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+ pRegions, true /* do lock */);
+ }
}
-static void entry_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags stageMask) {
+void gfxstream_vk_CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdSetEvent");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetEvent(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
+ }
}
-static void entry_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags stageMask) {
+void gfxstream_vk_CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetEvent(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
+ }
}
-static void entry_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) {
+void gfxstream_vk_CmdWaitEvents(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) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
- memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
- pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkEvent> internal_pEvents(eventCount);
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+ internal_pEvents[i] = gfxstream_pEvents->internal_object;
+ }
+ std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
+ for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+ internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
+ /* VkBufferMemoryBarrier::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferMemoryBarriers[i].buffer);
+ internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
+ }
+ std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
+ for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+ internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
+ /* VkImageMemoryBarrier::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_pImageMemoryBarriers[i].image);
+ internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
+ }
+ vkEnc->vkCmdWaitEvents(gfxstream_commandBuffer->internal_object, eventCount,
+ internal_pEvents.data(), srcStageMask, dstStageMask,
+ memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+ internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
+ internal_pImageMemoryBarriers.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdPipelineBarrier(
+void gfxstream_vk_CmdPipelineBarrier(
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) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- auto resources = ResourceTracker::get();
- resources->on_vkCmdPipelineBarrier(vkEnc, commandBuffer, srcStageMask, dstStageMask,
- dependencyFlags, memoryBarrierCount, pMemoryBarriers,
- bufferMemoryBarrierCount, pBufferMemoryBarriers,
- imageMemoryBarrierCount, pImageMemoryBarriers);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
+ for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+ internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
+ /* VkBufferMemoryBarrier::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferMemoryBarriers[i].buffer);
+ internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
+ }
+ std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
+ for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+ internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
+ /* VkImageMemoryBarrier::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_pImageMemoryBarriers[i].image);
+ internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkCmdPipelineBarrier(
+ vkEnc, gfxstream_commandBuffer->internal_object, srcStageMask, dstStageMask,
+ dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+ internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
+ internal_pImageMemoryBarriers.data());
+ }
}
-static void entry_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, VkQueryControlFlags flags) {
+void gfxstream_vk_CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags) {
AEMU_SCOPED_TRACE("vkCmdBeginQuery");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags, true /* do lock */);
-}
-static void entry_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query) {
- AEMU_SCOPED_TRACE("vkCmdEndQuery");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query, true /* do lock */);
-}
-static void entry_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount) {
- AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount,
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBeginQuery(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, flags,
true /* do lock */);
+ }
}
-static void entry_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
- uint32_t query) {
+void gfxstream_vk_CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query) {
+ AEMU_SCOPED_TRACE("vkCmdEndQuery");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndQuery(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount) {
+ AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetQueryPool(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, firstQuery, queryCount,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdWriteTimestamp(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
+ uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteTimestamp(gfxstream_commandBuffer->internal_object, pipelineStage,
+ gfxstream_queryPool->internal_object, query, true /* do lock */);
+ }
}
-static void entry_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount,
- VkBuffer dstBuffer, VkDeviceSize dstOffset,
- VkDeviceSize stride, VkQueryResultFlags flags) {
+void gfxstream_vk_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ VkDeviceSize stride, VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer,
- dstOffset, stride, flags, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyQueryPoolResults(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, firstQuery,
+ queryCount, gfxstream_dstBuffer->internal_object,
+ dstOffset, stride, flags, true /* do lock */);
+ }
}
-static void entry_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
- VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
- const void* pValues) {
+void gfxstream_vk_CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+ const void* pValues) {
AEMU_SCOPED_TRACE("vkCmdPushConstants");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdPushConstants(gfxstream_commandBuffer->internal_object,
+ gfxstream_layout->internal_object, stageFlags, offset, size,
+ pValues, true /* do lock */);
+ }
}
-static void entry_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- VkSubpassContents contents) {
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents, true /* do lock */);
-}
-static void entry_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+void gfxstream_vk_CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass(commandBuffer, contents, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdNextSubpass(gfxstream_commandBuffer->internal_object, contents,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRenderPass(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass(commandBuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderPass(gfxstream_commandBuffer->internal_object, true /* do lock */);
+ }
}
-static void entry_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers) {
+void gfxstream_vk_CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- auto resources = ResourceTracker::get();
- resources->on_vkCmdExecuteCommands(vkEnc, commandBuffer, commandBufferCount, pCommandBuffers);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCommandBuffer> internal_pCommandBuffers(commandBufferCount);
+ for (uint32_t i = 0; i < commandBufferCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+ pCommandBuffers[i]);
+ internal_pCommandBuffers[i] = gfxstream_pCommandBuffers->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkCmdExecuteCommands(vkEnc, gfxstream_commandBuffer->internal_object,
+ commandBufferCount, internal_pCommandBuffers.data());
+ }
}
#endif
#ifdef VK_VERSION_1_1
-static VkResult entry_vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
- AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
- vkEnumerateInstanceVersion_VkResult_return =
- vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
- return vkEnumerateInstanceVersion_VkResult_return;
-}
-static VkResult entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindBufferMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindBufferMemory2_VkResult_return =
- resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindBufferMemoryInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
+ internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
+ /* VkBindBufferMemoryInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindBufferMemory2_VkResult_return =
+ resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ bindInfoCount, internal_pBindInfos.data());
+ }
return vkBindBufferMemory2_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkBindBufferMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
- vkBindBufferMemory2_VkResult_return =
- resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindBufferMemory2_VkResult_return;
-}
-static VkResult entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindImageMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindImageMemory2_VkResult_return =
- resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindImageMemoryInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
+ internal_pBindInfos[i].image = gfxstream_image->internal_object;
+ /* VkBindImageMemoryInfo::memory */
+ if (internal_pBindInfos[i].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindImageMemory2_VkResult_return =
+ resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ bindInfoCount, internal_pBindInfos.data());
+ }
return vkBindImageMemory2_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkBindImageMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
- vkBindImageMemory2_VkResult_return =
- resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindImageMemory2_VkResult_return;
-}
-static void entry_vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
+void gfxstream_vk_GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
- remoteDeviceIndex, pPeerMemoryFeatures,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeatures", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceGroupPeerMemoryFeatures(gfxstream_device->internal_object, heapIndex,
+ localDeviceIndex, remoteDeviceIndex,
+ pPeerMemoryFeatures, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
- remoteDeviceIndex, pPeerMemoryFeatures,
- true /* do lock */);
}
-static void entry_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
+void gfxstream_vk_CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDeviceMask(gfxstream_commandBuffer->internal_object, deviceMask,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
- uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
- uint32_t groupCountY, uint32_t groupCountZ) {
+void gfxstream_vk_CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ) {
AEMU_SCOPED_TRACE("vkCmdDispatchBase");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
- groupCountY, groupCountZ, true /* do lock */);
-}
-static VkResult entry_vkEnumeratePhysicalDeviceGroups(
- VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
- AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
- vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(
- instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
- return vkEnumeratePhysicalDeviceGroups_VkResult_return;
-}
-static void entry_vkGetImageMemoryRequirements2(VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetImageMemoryRequirements2(
- VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDispatchBase(gfxstream_commandBuffer->internal_object, baseGroupX, baseGroupY,
+ baseGroupZ, groupCountX, groupCountY, groupCountZ,
+ true /* do lock */);
}
+}
+void gfxstream_vk_GetImageMemoryRequirements2(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void entry_vkGetBufferMemoryRequirements2(VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetBufferMemoryRequirements2(
- VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetImageMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
}
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetImageSparseMemoryRequirements2(
+void gfxstream_vk_GetBufferMemoryRequirements2(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
+ AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferMemoryRequirementsInfo2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetBufferMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
+ }
+}
+void gfxstream_vk_GetImageSparseMemoryRequirements2(
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSparseMemoryRequirements2(
- VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageSparseMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ vkEnc->vkGetImageSparseMemoryRequirements2(
+ gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2(gfxstream_physicalDevice->internal_object, pFeatures,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2(gfxstream_physicalDevice->internal_object,
+ pProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2(gfxstream_physicalDevice->internal_object,
+ format, pFormatProperties, true /* do lock */);
+ }
}
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
- resources->on_vkGetPhysicalDeviceImageFormatProperties2(
- vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
+ resources->on_vkGetPhysicalDeviceImageFormatProperties2(
+ vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
+ pImageFormatProperties);
+ }
return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(
+ gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceMemoryProperties2(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2(gfxstream_physicalDevice->internal_object,
+ pMemoryProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
- physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
-}
-static void entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- AEMU_SCOPED_TRACE("vkTrimCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
-}
-static void dynCheck_entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkTrimCommandPool", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
+ gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
+ true /* do lock */);
}
+}
+void gfxstream_vk_TrimCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
AEMU_SCOPED_TRACE("vkTrimCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
-}
-static void entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue) {
- AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceQueue2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkTrimCommandPool(gfxstream_device->internal_object,
+ gfxstream_commandPool->internal_object, flags, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
-static VkResult entry_vkCreateSamplerYcbcrConversion(
+VkResult gfxstream_vk_CreateSamplerYcbcrConversion(
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSamplerYcbcrConversion_VkResult_return =
+ resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS,
+ gfxstream_device->internal_object,
+ pCreateInfo, pAllocator, pYcbcrConversion);
+ }
return vkCreateSamplerYcbcrConversion_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversion(
- VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversion", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
- vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
- return vkCreateSamplerYcbcrConversion_VkResult_return;
-}
-static void entry_vkDestroySamplerYcbcrConversion(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySamplerYcbcrConversion(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
-}
-static void dynCheck_entry_vkDestroySamplerYcbcrConversion(
- VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversion", "VK_VERSION_1_1");
+ if (VK_NULL_HANDLE == ycbcrConversion) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroySamplerYcbcrConversion(vkEnc, gfxstream_device->internal_object,
+ ycbcrConversion, pAllocator);
+ }
}
-static VkResult entry_vkCreateDescriptorUpdateTemplate(
+VkResult gfxstream_vk_CreateDescriptorUpdateTemplate(
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
- device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
- return vkCreateDescriptorUpdateTemplate_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplate(
- VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplate", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
+ (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
+ VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
+ vkCreateDescriptorUpdateTemplate_VkResult_return =
+ gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorUpdateTemplate_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
+ if (internal_pCreateInfo[i].descriptorSetLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+ internal_pCreateInfo[i].descriptorSetLayout);
+ internal_pCreateInfo[i].descriptorSetLayout =
+ gfxstream_descriptorSetLayout->internal_object;
+ }
+ /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
+ if (internal_pCreateInfo[i].pipelineLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
+ internal_pCreateInfo[i].pipelineLayout);
+ internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
+ }
+ }
+ vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
- device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
+ *pDescriptorUpdateTemplate =
+ gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
-static void entry_vkDestroyDescriptorUpdateTemplate(
+void gfxstream_vk_DestroyDescriptorUpdateTemplate(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyDescriptorUpdateTemplate(
- VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplate", "VK_VERSION_1_1");
+ if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplate(
+ gfxstream_device->internal_object,
+ gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
+ : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
}
-static void entry_vkUpdateDescriptorSetWithTemplate(
+void gfxstream_vk_UpdateDescriptorSetWithTemplate(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
- descriptorUpdateTemplate, pData);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplate(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplate", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkUpdateDescriptorSetWithTemplate(
+ vkEnc, gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, pData);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
- descriptorUpdateTemplate, pData);
}
-static void entry_vkGetPhysicalDeviceExternalBufferProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalBufferProperties(
- vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalBufferProperties(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
+ pExternalBufferProperties);
+ }
}
-static void entry_vkGetPhysicalDeviceExternalFenceProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFenceProperties(
- vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalFenceProperties(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
+ pExternalFenceProperties);
+ }
}
-static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
- physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
-}
-static void entry_vkGetDescriptorSetLayoutSupport(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDescriptorSetLayoutSupport(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupport", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
+ gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
+ pExternalSemaphoreProperties, true /* do lock */);
}
+}
+void gfxstream_vk_GetDescriptorSetLayoutSupport(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport) {
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupport(gfxstream_device->internal_object, pCreateInfo,
+ pSupport, true /* do lock */);
+ }
}
#endif
#ifdef VK_VERSION_1_2
-static void entry_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkBuffer countBuffer,
- VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
- uint32_t stride) {
+void gfxstream_vk_CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
- maxDrawCount, stride, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndirectCount(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset,
+ gfxstream_countBuffer->internal_object, countBufferOffset,
+ maxDrawCount, stride, true /* do lock */);
+ }
}
-static void entry_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount, uint32_t stride) {
+void gfxstream_vk_CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer,
- countBufferOffset, maxDrawCount, stride,
- true /* do lock */);
-}
-static VkResult entry_vkCreateRenderPass2(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- AEMU_SCOPED_TRACE("vkCreateRenderPass2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
- vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
- return vkCreateRenderPass2_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateRenderPass2(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2", "VK_VERSION_1_2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndexedIndirectCount(
+ gfxstream_commandBuffer->internal_object, gfxstream_buffer->internal_object, offset,
+ gfxstream_countBuffer->internal_object, countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
+}
+VkResult gfxstream_vk_CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
- vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+ (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_render_pass),
+ VK_OBJECT_TYPE_RENDER_PASS);
+ vkCreateRenderPass2_VkResult_return =
+ gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateRenderPass2_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateRenderPass2_VkResult_return =
+ vkEnc->vkCreateRenderPass2(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pRenderPass->internal_object, true /* do lock */);
+ }
+ *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
return vkCreateRenderPass2_VkResult_return;
}
-static void entry_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo) {
+void gfxstream_vk_CmdBeginRenderPass2(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkRenderPassBeginInfo> internal_pRenderPassBegin(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pRenderPassBegin[i] = pRenderPassBegin[i];
+ /* VkRenderPassBeginInfo::renderPass */
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pRenderPassBegin[i].renderPass);
+ internal_pRenderPassBegin[i].renderPass = gfxstream_renderPass->internal_object;
+ /* VkRenderPassBeginInfo::framebuffer */
+ VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_pRenderPassBegin[i].framebuffer);
+ internal_pRenderPassBegin[i].framebuffer = gfxstream_framebuffer->internal_object;
+ }
+ vkEnc->vkCmdBeginRenderPass2(gfxstream_commandBuffer->internal_object,
+ internal_pRenderPassBegin.data(), pSubpassBeginInfo,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo) {
+void gfxstream_vk_CmdNextSubpass2(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdNextSubpass2(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
+ pSubpassEndInfo, true /* do lock */);
+ }
}
-static void entry_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
+void gfxstream_vk_CmdEndRenderPass2(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo, true /* do lock */);
-}
-static void entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
- uint32_t queryCount) {
- AEMU_SCOPED_TRACE("vkResetQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
-}
-static void dynCheck_entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkResetQueryPool", "VK_VERSION_1_2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderPass2(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkResetQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
-static VkResult entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
- uint64_t* pValue) {
+void gfxstream_vk_ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount) {
+ AEMU_SCOPED_TRACE("vkResetQueryPool");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkResetQueryPool(gfxstream_device->internal_object,
+ gfxstream_queryPool->internal_object, firstQuery, queryCount,
+ true /* do lock */);
+ }
+}
+VkResult gfxstream_vk_GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue) {
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValue_VkResult_return =
- vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetSemaphoreCounterValue_VkResult_return = vkEnc->vkGetSemaphoreCounterValue(
+ gfxstream_device->internal_object, gfxstream_semaphore->internal_object, pValue,
+ true /* do lock */);
+ }
return vkGetSemaphoreCounterValue_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
- uint64_t* pValue) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValue", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValue_VkResult_return =
- vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
- return vkGetSemaphoreCounterValue_VkResult_return;
-}
-static VkResult entry_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout) {
+VkResult gfxstream_vk_WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitSemaphores");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
- vkWaitSemaphores_VkResult_return =
- vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkSemaphoreWaitInfo> internal_pWaitInfo(1);
+ std::vector<std::vector<VkSemaphore>> internal_VkSemaphoreWaitInfo_pSemaphores;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pWaitInfo[i] = pWaitInfo[i];
+ /* VkSemaphoreWaitInfo::pSemaphores */
+ internal_VkSemaphoreWaitInfo_pSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSemaphoreWaitInfo_pSemaphores[i] = transformVkSemaphoreList(
+ internal_pWaitInfo[i].pSemaphores, internal_pWaitInfo[i].semaphoreCount);
+ internal_pWaitInfo[i].pSemaphores = internal_VkSemaphoreWaitInfo_pSemaphores[i].data();
+ internal_pWaitInfo[i].semaphoreCount =
+ internal_VkSemaphoreWaitInfo_pSemaphores[i].size();
+ }
+ vkWaitSemaphores_VkResult_return =
+ vkEnc->vkWaitSemaphores(gfxstream_device->internal_object, internal_pWaitInfo.data(),
+ timeout, true /* do lock */);
+ }
return vkWaitSemaphores_VkResult_return;
}
-static VkResult dynCheck_entry_vkWaitSemaphores(VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkWaitSemaphores", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkWaitSemaphores");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
- vkWaitSemaphores_VkResult_return =
- vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
- return vkWaitSemaphores_VkResult_return;
-}
-static VkResult entry_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
+VkResult gfxstream_vk_SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
AEMU_SCOPED_TRACE("vkSignalSemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
- vkSignalSemaphore_VkResult_return =
- vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkSemaphoreSignalInfo> internal_pSignalInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pSignalInfo[i] = pSignalInfo[i];
+ /* VkSemaphoreSignalInfo::semaphore */
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+ internal_pSignalInfo[i].semaphore);
+ internal_pSignalInfo[i].semaphore = gfxstream_semaphore->internal_object;
+ }
+ vkSignalSemaphore_VkResult_return = vkEnc->vkSignalSemaphore(
+ gfxstream_device->internal_object, internal_pSignalInfo.data(), true /* do lock */);
+ }
return vkSignalSemaphore_VkResult_return;
}
-static VkResult dynCheck_entry_vkSignalSemaphore(VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkSignalSemaphore", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkSignalSemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
- vkSignalSemaphore_VkResult_return =
- vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
- return vkSignalSemaphore_VkResult_return;
-}
-static VkDeviceAddress entry_vkGetBufferDeviceAddress(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+VkDeviceAddress gfxstream_vk_GetBufferDeviceAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddress_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferDeviceAddress_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddress(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
-static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddress(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddress", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddress_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
- return vkGetBufferDeviceAddress_VkDeviceAddress_return;
-}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddress(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddress(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
-static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddress(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddress", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
- return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
-}
-static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddress(
+uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddress(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
- return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
-}
-static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress(
- VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddress", "VK_VERSION_1_2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+ internal_pInfo[i].memory = gfxstream_memory->internal_object;
+ }
+ vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(gfxstream_device->internal_object,
+ internal_pInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
#endif
#ifdef VK_VERSION_1_3
-static VkResult entry_vkGetPhysicalDeviceToolProperties(
+VkResult gfxstream_vk_GetPhysicalDeviceToolProperties(
VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
VkPhysicalDeviceToolProperties* pToolProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceToolProperties_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceToolProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceToolProperties(
- physicalDevice, pToolCount, pToolProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPhysicalDeviceToolProperties_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceToolProperties(gfxstream_physicalDevice->internal_object,
+ pToolCount, pToolProperties,
+ true /* do lock */);
+ }
return vkGetPhysicalDeviceToolProperties_VkResult_return;
}
-static VkResult entry_vkCreatePrivateDataSlot(VkDevice device,
- const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlot* pPrivateDataSlot) {
+VkResult gfxstream_vk_CreatePrivateDataSlot(VkDevice device,
+ const VkPrivateDataSlotCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPrivateDataSlot* pPrivateDataSlot) {
AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreatePrivateDataSlot_VkResult_return =
+ vkEnc->vkCreatePrivateDataSlot(gfxstream_device->internal_object, pCreateInfo,
+ pAllocator, pPrivateDataSlot, true /* do lock */);
+ }
return vkCreatePrivateDataSlot_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreatePrivateDataSlot(
- VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlot", "VK_VERSION_1_3");
- }
- AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
- return vkCreatePrivateDataSlot_VkResult_return;
-}
-static void entry_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyPrivateDataSlot(VkDevice device,
- VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlot", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPrivateDataSlot(gfxstream_device->internal_object, privateDataSlot,
+ pAllocator, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
}
-static VkResult entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
+VkResult gfxstream_vk_SetPrivateData(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+ uint64_t data) {
AEMU_SCOPED_TRACE("vkSetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
- vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkSetPrivateData_VkResult_return =
+ vkEnc->vkSetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, data, true /* do lock */);
+ }
return vkSetPrivateData_VkResult_return;
}
-static VkResult dynCheck_entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t data) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkSetPrivateData", "VK_VERSION_1_3");
- }
- AEMU_SCOPED_TRACE("vkSetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
- vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
- return vkSetPrivateData_VkResult_return;
-}
-static void entry_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
+void gfxstream_vk_GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+ VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
AEMU_SCOPED_TRACE("vkGetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetPrivateData(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetPrivateData", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, pData, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
}
-static void entry_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdSetEvent2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent2(commandBuffer, event, pDependencyInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdSetEvent2(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, internal_pDependencyInfo.data(),
+ true /* do lock */);
+ }
}
-static void entry_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
+void gfxstream_vk_CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2 stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent2(commandBuffer, event, stageMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetEvent2(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
+ }
}
-static void entry_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfo* pDependencyInfos) {
+void gfxstream_vk_CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkEvent> internal_pEvents(eventCount);
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+ internal_pEvents[i] = gfxstream_pEvents->internal_object;
+ }
+ std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ internal_pDependencyInfos[i] = pDependencyInfos[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfos[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfos[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdWaitEvents2(gfxstream_commandBuffer->internal_object, eventCount,
+ internal_pEvents.data(), internal_pDependencyInfos.data(),
+ true /* do lock */);
+ }
}
-static void entry_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdPipelineBarrier2(gfxstream_commandBuffer->internal_object,
+ internal_pDependencyInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
- VkQueryPool queryPool, uint32_t query) {
+void gfxstream_vk_CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+ VkQueryPool queryPool, uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteTimestamp2(gfxstream_commandBuffer->internal_object, stage,
+ gfxstream_queryPool->internal_object, query,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkQueueSubmit2(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit2(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit2");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueSubmit2_VkResult_return =
- resources->on_vkQueueSubmit2(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+ std::vector<std::vector<VkCommandBufferSubmitInfo>>
+ internal_VkSubmitInfo2_pCommandBufferInfos;
+ std::vector<std::vector<VkSemaphoreSubmitInfo>>
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo2::pWaitSemaphoreInfos */
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+ internal_pSubmits[i].waitSemaphoreInfoCount);
+ internal_pSubmits[i].pWaitSemaphoreInfos =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+ internal_pSubmits[i].waitSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+ /* VkSubmitInfo2::pCommandBufferInfos */
+ internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+ std::vector<VkCommandBufferSubmitInfo>());
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+ internal_pSubmits[i].commandBufferInfoCount);
+ memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+ sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+ internal_pSubmits[i].pCommandBufferInfos[j];
+ /* VkCommandBufferSubmitInfo::commandBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+ gfxstream_commandBuffer->internal_object;
+ }
+ internal_pSubmits[i].pCommandBufferInfos =
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+ /* VkSubmitInfo2::pSignalSemaphoreInfos */
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+ internal_pSubmits[i].signalSemaphoreInfoCount);
+ internal_pSubmits[i].pSignalSemaphoreInfos =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+ internal_pSubmits[i].signalSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueSubmit2_VkResult_return = resources->on_vkQueueSubmit2(
+ vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
+ internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
+ }
return vkQueueSubmit2_VkResult_return;
}
-static void entry_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
+void gfxstream_vk_CmdCopyBuffer2(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2* pCopyBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBuffer2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
+ /* VkCopyBufferInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferInfo[i].srcBuffer);
+ internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyBufferInfo[i].dstBuffer);
+ internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyBuffer2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdCopyImage2(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
+void gfxstream_vk_CmdCopyImage2(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2* pCopyImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage2(commandBuffer, pCopyImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageInfo[i] = pCopyImageInfo[i];
+ /* VkCopyImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageInfo[i].srcImage);
+ internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyImageInfo[i].dstImage);
+ internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyImage2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+void gfxstream_vk_CmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
+ const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
+ /* VkCopyBufferToImageInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferToImageInfo[i].srcBuffer);
+ internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferToImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyBufferToImageInfo[i].dstImage);
+ internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyBufferToImage2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferToImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+void gfxstream_vk_CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
+ const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
+ /* VkCopyImageToBufferInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToBufferInfo[i].srcImage);
+ internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageToBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyImageToBufferInfo[i].dstBuffer);
+ internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyImageToBuffer2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageToBufferInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdBlitImage2(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
+void gfxstream_vk_CmdBlitImage2(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2* pBlitImageInfo) {
AEMU_SCOPED_TRACE("vkCmdBlitImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage2(commandBuffer, pBlitImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBlitImageInfo[i] = pBlitImageInfo[i];
+ /* VkBlitImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pBlitImageInfo[i].srcImage);
+ internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkBlitImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pBlitImageInfo[i].dstImage);
+ internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdBlitImage2(gfxstream_commandBuffer->internal_object,
+ internal_pBlitImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdResolveImage2(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
+void gfxstream_vk_CmdResolveImage2(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2* pResolveImageInfo) {
AEMU_SCOPED_TRACE("vkCmdResolveImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage2(commandBuffer, pResolveImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pResolveImageInfo[i] = pResolveImageInfo[i];
+ /* VkResolveImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pResolveImageInfo[i].srcImage);
+ internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkResolveImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pResolveImageInfo[i].dstImage);
+ internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdResolveImage2(gfxstream_commandBuffer->internal_object,
+ internal_pResolveImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdBeginRendering(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
+void gfxstream_vk_CmdBeginRendering(VkCommandBuffer commandBuffer,
+ const VkRenderingInfo* pRenderingInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRendering");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRendering(commandBuffer, pRenderingInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
+ std::vector<std::vector<VkRenderingAttachmentInfo>>
+ internal_VkRenderingInfo_pColorAttachments;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pRenderingInfo[i] = pRenderingInfo[i];
+ /* VkRenderingInfo::pColorAttachments */
+ internal_VkRenderingInfo_pColorAttachments.push_back(
+ std::vector<VkRenderingAttachmentInfo>());
+ internal_VkRenderingInfo_pColorAttachments[i].reserve(
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
+ sizeof(VkRenderingAttachmentInfo) *
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
+ internal_VkRenderingInfo_pColorAttachments[i][j] =
+ internal_pRenderingInfo[i].pColorAttachments[j];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ }
+ internal_pRenderingInfo[i].pColorAttachments =
+ internal_VkRenderingInfo_pColorAttachments[i].data();
+ /* VkRenderingInfo::pDepthAttachment */
+ if (internal_pRenderingInfo[i].pDepthAttachment) {
+ internal_VkRenderingInfo_pDepthAttachment[i] =
+ internal_pRenderingInfo[i].pDepthAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pDepthAttachment =
+ &internal_VkRenderingInfo_pDepthAttachment[i];
+ }
+ /* VkRenderingInfo::pStencilAttachment */
+ if (internal_pRenderingInfo[i].pStencilAttachment) {
+ internal_VkRenderingInfo_pStencilAttachment[i] =
+ internal_pRenderingInfo[i].pStencilAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pStencilAttachment =
+ &internal_VkRenderingInfo_pStencilAttachment[i];
+ }
+ }
+ vkEnc->vkCmdBeginRendering(gfxstream_commandBuffer->internal_object,
+ internal_pRenderingInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdEndRendering(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRendering(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRendering");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRendering(commandBuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRendering(gfxstream_commandBuffer->internal_object, true /* do lock */);
+ }
}
-static void entry_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+void gfxstream_vk_CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
AEMU_SCOPED_TRACE("vkCmdSetCullMode");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCullMode(commandBuffer, cullMode, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetCullMode(gfxstream_commandBuffer->internal_object, cullMode,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+void gfxstream_vk_CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
AEMU_SCOPED_TRACE("vkCmdSetFrontFace");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFrontFace(commandBuffer, frontFace, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetFrontFace(gfxstream_commandBuffer->internal_object, frontFace,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
+void gfxstream_vk_CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopology");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveTopology(gfxstream_commandBuffer->internal_object,
+ primitiveTopology, true /* do lock */);
+ }
}
-static void entry_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
- const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+ const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewportWithCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetViewportWithCount(gfxstream_commandBuffer->internal_object, viewportCount,
+ pViewports, true /* do lock */);
+ }
}
-static void entry_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
- const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+ const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissorWithCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetScissorWithCount(gfxstream_commandBuffer->internal_object, scissorCount,
+ pScissors, true /* do lock */);
+ }
}
-static void entry_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
+void gfxstream_vk_CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides) {
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- pSizes, pStrides, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ if (pBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBindVertexBuffers2(gfxstream_commandBuffer->internal_object, firstBinding,
+ bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
+ pStrides, true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
+void gfxstream_vk_CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthTestEnable(gfxstream_commandBuffer->internal_object, depthTestEnable,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable) {
+void gfxstream_vk_CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthWriteEnable(gfxstream_commandBuffer->internal_object, depthWriteEnable,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp) {
+void gfxstream_vk_CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOp");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthCompareOp(gfxstream_commandBuffer->internal_object, depthCompareOp,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
+void gfxstream_vk_CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBoundsTestEnable(gfxstream_commandBuffer->internal_object,
+ depthBoundsTestEnable, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
+void gfxstream_vk_CmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
+ VkBool32 stencilTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilTestEnable(gfxstream_commandBuffer->internal_object,
+ stencilTestEnable, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
- VkCompareOp compareOp) {
+void gfxstream_vk_CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
+ VkCompareOp compareOp) {
AEMU_SCOPED_TRACE("vkCmdSetStencilOp");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilOp(gfxstream_commandBuffer->internal_object, faceMask, failOp, passOp,
+ depthFailOp, compareOp, true /* do lock */);
+ }
}
-static void entry_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
+void gfxstream_vk_CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable) {
AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetRasterizerDiscardEnable(gfxstream_commandBuffer->internal_object,
+ rasterizerDiscardEnable, true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
+void gfxstream_vk_CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBiasEnable(gfxstream_commandBuffer->internal_object, depthBiasEnable,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
+void gfxstream_vk_CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable,
- true /* do lock */);
-}
-static void entry_vkGetDeviceBufferMemoryRequirements(VkDevice device,
- const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceBufferMemoryRequirements(
- VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirements", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveRestartEnable(gfxstream_commandBuffer->internal_object,
+ primitiveRestartEnable, true /* do lock */);
}
+}
+void gfxstream_vk_GetDeviceBufferMemoryRequirements(VkDevice device,
+ const VkDeviceBufferMemoryRequirements* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void entry_vkGetDeviceImageMemoryRequirements(VkDevice device,
- const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageMemoryRequirements(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirements", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceBufferMemoryRequirements(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageSparseMemoryRequirements(
+void gfxstream_vk_GetDeviceImageMemoryRequirements(VkDevice device,
+ const VkDeviceImageMemoryRequirements* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
+ AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageMemoryRequirements(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
+ }
+}
+void gfxstream_vk_GetDeviceImageSparseMemoryRequirements(
VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirements",
- "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageSparseMemoryRequirements(
+ gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
}
#endif
#ifdef VK_KHR_surface
@@ -2171,140 +3720,236 @@
#ifdef VK_KHR_xcb_surface
#endif
#ifdef VK_KHR_android_surface
-static VkResult entry_vkCreateAndroidSurfaceKHR(VkInstance instance,
- const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface) {
+VkResult gfxstream_vk_CreateAndroidSurfaceKHR(VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(
- instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_instance, gfxstream_instance, instance);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateAndroidSurfaceKHR_VkResult_return =
+ vkEnc->vkCreateAndroidSurfaceKHR(gfxstream_instance->internal_object, pCreateInfo,
+ pAllocator, pSurface, true /* do lock */);
+ }
return vkCreateAndroidSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_win32_surface
#endif
#ifdef VK_KHR_dynamic_rendering
-static void entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
+void gfxstream_vk_CmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
+ const VkRenderingInfo* pRenderingInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderingKHR", "VK_KHR_dynamic_rendering");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
+ std::vector<std::vector<VkRenderingAttachmentInfo>>
+ internal_VkRenderingInfo_pColorAttachments;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pRenderingInfo[i] = pRenderingInfo[i];
+ /* VkRenderingInfo::pColorAttachments */
+ internal_VkRenderingInfo_pColorAttachments.push_back(
+ std::vector<VkRenderingAttachmentInfo>());
+ internal_VkRenderingInfo_pColorAttachments[i].reserve(
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
+ sizeof(VkRenderingAttachmentInfo) *
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
+ internal_VkRenderingInfo_pColorAttachments[i][j] =
+ internal_pRenderingInfo[i].pColorAttachments[j];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ }
+ internal_pRenderingInfo[i].pColorAttachments =
+ internal_VkRenderingInfo_pColorAttachments[i].data();
+ /* VkRenderingInfo::pDepthAttachment */
+ if (internal_pRenderingInfo[i].pDepthAttachment) {
+ internal_VkRenderingInfo_pDepthAttachment[i] =
+ internal_pRenderingInfo[i].pDepthAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pDepthAttachment =
+ &internal_VkRenderingInfo_pDepthAttachment[i];
+ }
+ /* VkRenderingInfo::pStencilAttachment */
+ if (internal_pRenderingInfo[i].pStencilAttachment) {
+ internal_VkRenderingInfo_pStencilAttachment[i] =
+ internal_pRenderingInfo[i].pStencilAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pStencilAttachment =
+ &internal_VkRenderingInfo_pStencilAttachment[i];
+ }
+ }
+ vkEnc->vkCmdBeginRenderingKHR(gfxstream_commandBuffer->internal_object,
+ internal_pRenderingInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
}
-static void entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderingKHR", "VK_KHR_dynamic_rendering");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderingKHR(gfxstream_commandBuffer->internal_object, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
-static void entry_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2KHR(gfxstream_physicalDevice->internal_object, pFeatures,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2KHR(gfxstream_physicalDevice->internal_object,
+ pProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(gfxstream_physicalDevice->internal_object,
+ format, pFormatProperties,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
- resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
- vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
+ resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
+ pImageFormatProperties);
+ }
return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2KHR(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties2KHR(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(gfxstream_physicalDevice->internal_object,
+ pMemoryProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
- physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
+ true /* do lock */);
+ }
}
#endif
#ifdef VK_KHR_maintenance1
-static void entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
+void gfxstream_vk_TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
-}
-static void dynCheck_entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance1")) {
- sOnInvalidDynamicallyCheckedCall("vkTrimCommandPoolKHR", "VK_KHR_maintenance1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkTrimCommandPoolKHR(gfxstream_device->internal_object,
+ gfxstream_commandPool->internal_object, flags,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_memory_capabilities
-static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalBufferPropertiesKHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
- vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
+ pExternalBufferProperties);
+ }
}
#endif
#ifdef VK_KHR_external_memory
@@ -2314,14 +3959,18 @@
#ifdef VK_KHR_external_memory_fd
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalSemaphorePropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
- physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
+ pExternalSemaphoreProperties, true /* do lock */);
+ }
}
#endif
#ifdef VK_KHR_external_semaphore
@@ -2329,51 +3978,47 @@
#ifdef VK_KHR_external_semaphore_win32
#endif
#ifdef VK_KHR_external_semaphore_fd
-static VkResult entry_vkImportSemaphoreFdKHR(
+VkResult gfxstream_vk_ImportSemaphoreFdKHR(
VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkImportSemaphoreFdKHR_VkResult_return =
- resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImportSemaphoreFdInfoKHR> internal_pImportSemaphoreFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pImportSemaphoreFdInfo[i] = pImportSemaphoreFdInfo[i];
+ /* VkImportSemaphoreFdInfoKHR::semaphore */
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+ internal_pImportSemaphoreFdInfo[i].semaphore);
+ internal_pImportSemaphoreFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkImportSemaphoreFdKHR_VkResult_return = resources->on_vkImportSemaphoreFdKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ internal_pImportSemaphoreFdInfo.data());
+ }
return vkImportSemaphoreFdKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkImportSemaphoreFdKHR(
- VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
- }
- AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
- vkImportSemaphoreFdKHR_VkResult_return =
- resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
- return vkImportSemaphoreFdKHR_VkResult_return;
-}
-static VkResult entry_vkGetSemaphoreFdKHR(VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
+VkResult gfxstream_vk_GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetSemaphoreFdKHR_VkResult_return =
- resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
- return vkGetSemaphoreFdKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetSemaphoreFdKHR(VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
- int* pFd) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkSemaphoreGetFdInfoKHR> internal_pGetFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pGetFdInfo[i] = pGetFdInfo[i];
+ /* VkSemaphoreGetFdInfoKHR::semaphore */
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+ internal_pGetFdInfo[i].semaphore);
+ internal_pGetFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetSemaphoreFdKHR_VkResult_return = resources->on_vkGetSemaphoreFdKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
}
- AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
- vkGetSemaphoreFdKHR_VkResult_return =
- resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetSemaphoreFdKHR_VkResult_return;
}
#endif
@@ -2382,228 +4027,189 @@
#ifdef VK_KHR_incremental_present
#endif
#ifdef VK_KHR_descriptor_update_template
-static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
+VkResult gfxstream_vk_CreateDescriptorUpdateTemplateKHR(
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
+ (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
+ VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
- vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
- pDescriptorUpdateTemplate, true /* do lock */);
- return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR(
- VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplateKHR",
- "VK_KHR_descriptor_update_template");
+ gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorUpdateTemplateKHR_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
+ if (internal_pCreateInfo[i].descriptorSetLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+ internal_pCreateInfo[i].descriptorSetLayout);
+ internal_pCreateInfo[i].descriptorSetLayout =
+ gfxstream_descriptorSetLayout->internal_object;
+ }
+ /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
+ if (internal_pCreateInfo[i].pipelineLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
+ internal_pCreateInfo[i].pipelineLayout);
+ internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
+ }
+ }
+ vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
+ vkEnc->vkCreateDescriptorUpdateTemplateKHR(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
- vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
- pDescriptorUpdateTemplate, true /* do lock */);
+ *pDescriptorUpdateTemplate =
+ gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
}
-static void entry_vkDestroyDescriptorUpdateTemplateKHR(
+void gfxstream_vk_DestroyDescriptorUpdateTemplateKHR(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR(
- VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplateKHR",
- "VK_KHR_descriptor_update_template");
+ if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplateKHR(
+ gfxstream_device->internal_object,
+ gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
+ : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
}
-static void entry_vkUpdateDescriptorSetWithTemplateKHR(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateKHR(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
- pData, true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateKHR",
- "VK_KHR_descriptor_update_template");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkUpdateDescriptorSetWithTemplateKHR(
+ gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, pData, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
- pData, true /* do lock */);
}
#endif
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
-static VkResult entry_vkCreateRenderPass2KHR(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
+VkResult gfxstream_vk_CreateRenderPass2KHR(VkDevice device,
+ const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
- vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+ (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_render_pass),
+ VK_OBJECT_TYPE_RENDER_PASS);
+ vkCreateRenderPass2KHR_VkResult_return =
+ gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateRenderPass2KHR_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pRenderPass->internal_object, true /* do lock */);
+ }
+ *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
return vkCreateRenderPass2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateRenderPass2KHR(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2KHR", "VK_KHR_create_renderpass2");
+void gfxstream_vk_CmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
+ AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdNextSubpass2KHR(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
+ pSubpassEndInfo, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
- vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
- return vkCreateRenderPass2KHR_VkResult_return;
}
-static void entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo) {
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderPass2KHR", "VK_KHR_create_renderpass2");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
- true /* do lock */);
-}
-static void entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
+void gfxstream_vk_CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
const VkSubpassEndInfo* pSubpassEndInfo) {
- AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdNextSubpass2KHR", "VK_KHR_create_renderpass2");
- }
- AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
- true /* do lock */);
-}
-static void entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderPass2KHR", "VK_KHR_create_renderpass2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderPass2KHR(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_fence_capabilities
-static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalFencePropertiesKHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
- vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
+ pExternalFenceProperties);
+ }
}
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_fd
-static VkResult entry_vkImportFenceFdKHR(VkDevice device,
- const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
+VkResult gfxstream_vk_ImportFenceFdKHR(VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkImportFenceFdKHR_VkResult_return =
- resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImportFenceFdInfoKHR> internal_pImportFenceFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pImportFenceFdInfo[i] = pImportFenceFdInfo[i];
+ /* VkImportFenceFdInfoKHR::fence */
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence,
+ internal_pImportFenceFdInfo[i].fence);
+ internal_pImportFenceFdInfo[i].fence = gfxstream_fence->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkImportFenceFdKHR_VkResult_return =
+ resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ internal_pImportFenceFdInfo.data());
+ }
return vkImportFenceFdKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkImportFenceFdKHR(
- VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkImportFenceFdKHR", "VK_KHR_external_fence_fd");
- }
- AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
- vkImportFenceFdKHR_VkResult_return =
- resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
- return vkImportFenceFdKHR_VkResult_return;
-}
-static VkResult entry_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
- int* pFd) {
+VkResult gfxstream_vk_GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetFenceFdKHR_VkResult_return =
- resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
- return vkGetFenceFdKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetFenceFdKHR(VkDevice device,
- const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkGetFenceFdKHR", "VK_KHR_external_fence_fd");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFenceGetFdInfoKHR> internal_pGetFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pGetFdInfo[i] = pGetFdInfo[i];
+ /* VkFenceGetFdInfoKHR::fence */
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, internal_pGetFdInfo[i].fence);
+ internal_pGetFdInfo[i].fence = gfxstream_fence->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetFenceFdKHR_VkResult_return = resources->on_vkGetFenceFdKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
}
- AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
- vkGetFenceFdKHR_VkResult_return =
- resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetFenceFdKHR_VkResult_return;
}
#endif
@@ -2614,189 +4220,165 @@
#ifdef VK_KHR_storage_buffer_storage_class
#endif
#ifdef VK_KHR_get_memory_requirements2
-static void entry_vkGetImageMemoryRequirements2KHR(VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetImageMemoryRequirements2KHR(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetImageMemoryRequirements2KHR(
- VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2KHR",
- "VK_KHR_get_memory_requirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
}
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetBufferMemoryRequirements2KHR(VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetBufferMemoryRequirements2KHR(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetBufferMemoryRequirements2KHR(
- VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2KHR",
- "VK_KHR_get_memory_requirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferMemoryRequirementsInfo2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
}
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetImageSparseMemoryRequirements2KHR(
+void gfxstream_vk_GetImageSparseMemoryRequirements2KHR(
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR(
- VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2KHR",
- "VK_KHR_get_memory_requirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageSparseMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ vkEnc->vkGetImageSparseMemoryRequirements2KHR(
+ gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
}
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
+VkResult gfxstream_vk_CreateSamplerYcbcrConversionKHR(
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSamplerYcbcrConversionKHR_VkResult_return =
- resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
- pAllocator, pYcbcrConversion);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSamplerYcbcrConversionKHR_VkResult_return =
+ resources->on_vkCreateSamplerYcbcrConversionKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ pYcbcrConversion);
+ }
return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversionKHR(
- VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversionKHR",
- "VK_KHR_sampler_ycbcr_conversion");
- }
- AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
- vkCreateSamplerYcbcrConversionKHR_VkResult_return =
- resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
- pAllocator, pYcbcrConversion);
- return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
-}
-static void entry_vkDestroySamplerYcbcrConversionKHR(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySamplerYcbcrConversionKHR(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
-}
-static void dynCheck_entry_vkDestroySamplerYcbcrConversionKHR(
- VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
- sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversionKHR",
- "VK_KHR_sampler_ycbcr_conversion");
+ if (VK_NULL_HANDLE == ycbcrConversion) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, gfxstream_device->internal_object,
+ ycbcrConversion, pAllocator);
+ }
}
#endif
#ifdef VK_KHR_bind_memory2
-static VkResult entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindBufferMemory2KHR_VkResult_return =
- resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindBufferMemoryInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
+ internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
+ /* VkBindBufferMemoryInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindBufferMemory2KHR_VkResult_return = resources->on_vkBindBufferMemory2KHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
+ internal_pBindInfos.data());
+ }
return vkBindBufferMemory2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
- sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2KHR", "VK_KHR_bind_memory2");
- }
- AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
- vkBindBufferMemory2KHR_VkResult_return =
- resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindBufferMemory2KHR_VkResult_return;
-}
-static VkResult entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindImageMemory2KHR_VkResult_return =
- resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindImageMemory2KHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
- sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2KHR", "VK_KHR_bind_memory2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindImageMemoryInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
+ internal_pBindInfos[i].image = gfxstream_image->internal_object;
+ /* VkBindImageMemoryInfo::memory */
+ if (internal_pBindInfos[i].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindImageMemory2KHR_VkResult_return = resources->on_vkBindImageMemory2KHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
+ internal_pBindInfos.data());
}
- AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
- vkBindImageMemory2KHR_VkResult_return =
- resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2KHR_VkResult_return;
}
#endif
#ifdef VK_KHR_maintenance3
-static void entry_vkGetDescriptorSetLayoutSupportKHR(
+void gfxstream_vk_GetDescriptorSetLayoutSupportKHR(
VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance3")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupportKHR",
- "VK_KHR_maintenance3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupportKHR(gfxstream_device->internal_object, pCreateInfo,
+ pSupport, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
}
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
@@ -2806,160 +4388,135 @@
#ifdef VK_KHR_shader_terminate_invocation
#endif
#ifdef VK_KHR_buffer_device_address
-static VkDeviceAddress entry_vkGetBufferDeviceAddressKHR(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+VkDeviceAddress gfxstream_vk_GetBufferDeviceAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressKHR(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
}
-static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddressKHR(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressKHR",
- "VK_KHR_buffer_device_address");
- }
- AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
- return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
-}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetBufferOpaqueCaptureAddressKHR(gfxstream_device->internal_object,
+ internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
}
-static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddressKHR",
- "VK_KHR_buffer_device_address");
- }
- AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
- return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
-}
-static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddressKHR(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
- return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
-}
-static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
- VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddressKHR",
- "VK_KHR_buffer_device_address");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+ internal_pInfo[i].memory = gfxstream_memory->internal_object;
+ }
+ vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
-static VkResult entry_vkGetPipelineExecutablePropertiesKHR(
+VkResult gfxstream_vk_GetPipelineExecutablePropertiesKHR(
VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
VkPipelineExecutablePropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutablePropertiesKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
- pProperties, true /* do lock */);
- return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutablePropertiesKHR(
- VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
- VkPipelineExecutablePropertiesKHR* pProperties) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutablePropertiesKHR",
- "VK_KHR_pipeline_executable_properties");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineInfoKHR> internal_pPipelineInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pPipelineInfo[i] = pPipelineInfo[i];
+ /* VkPipelineInfoKHR::pipeline */
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+ internal_pPipelineInfo[i].pipeline);
+ internal_pPipelineInfo[i].pipeline = gfxstream_pipeline->internal_object;
+ }
+ vkGetPipelineExecutablePropertiesKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutablePropertiesKHR(
+ gfxstream_device->internal_object, internal_pPipelineInfo.data(), pExecutableCount,
+ pProperties, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutablePropertiesKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
- pProperties, true /* do lock */);
return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
}
-static VkResult entry_vkGetPipelineExecutableStatisticsKHR(
+VkResult gfxstream_vk_GetPipelineExecutableStatisticsKHR(
VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
VkPipelineExecutableStatisticKHR* pStatistics) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableStatisticsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
- pStatistics, true /* do lock */);
- return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutableStatisticsKHR(
- VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
- VkPipelineExecutableStatisticKHR* pStatistics) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableStatisticsKHR",
- "VK_KHR_pipeline_executable_properties");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pExecutableInfo[i] = pExecutableInfo[i];
+ /* VkPipelineExecutableInfoKHR::pipeline */
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+ internal_pExecutableInfo[i].pipeline);
+ internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
+ }
+ vkGetPipelineExecutableStatisticsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableStatisticsKHR(
+ gfxstream_device->internal_object, internal_pExecutableInfo.data(), pStatisticCount,
+ pStatistics, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableStatisticsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
- pStatistics, true /* do lock */);
return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
}
-static VkResult entry_vkGetPipelineExecutableInternalRepresentationsKHR(
+VkResult gfxstream_vk_GetPipelineExecutableInternalRepresentationsKHR(
VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
- device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
- true /* do lock */);
- return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR(
- VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
- uint32_t* pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableInternalRepresentationsKHR",
- "VK_KHR_pipeline_executable_properties");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pExecutableInfo[i] = pExecutableInfo[i];
+ /* VkPipelineExecutableInfoKHR::pipeline */
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+ internal_pExecutableInfo[i].pipeline);
+ internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
+ }
+ vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
+ gfxstream_device->internal_object, internal_pExecutableInfo.data(),
+ pInternalRepresentationCount, pInternalRepresentations, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
- device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
- true /* do lock */);
return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
}
#endif
@@ -2968,652 +4525,726 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_synchronization2
-static void entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetEvent2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdSetEvent2KHR(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, internal_pDependencyInfo.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
}
-static void entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
+void gfxstream_vk_CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2 stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdResetEvent2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetEvent2KHR(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
}
-static void entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfo* pDependencyInfos) {
+void gfxstream_vk_CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents,
+ const VkDependencyInfo* pDependencyInfos) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfo* pDependencyInfos) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdWaitEvents2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkEvent> internal_pEvents(eventCount);
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+ internal_pEvents[i] = gfxstream_pEvents->internal_object;
+ }
+ std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ internal_pDependencyInfos[i] = pDependencyInfos[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfos[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfos[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdWaitEvents2KHR(gfxstream_commandBuffer->internal_object, eventCount,
+ internal_pEvents.data(), internal_pDependencyInfos.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
- true /* do lock */);
}
-static void entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdPipelineBarrier2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdPipelineBarrier2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pDependencyInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
}
-static void entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage, VkQueryPool queryPool,
- uint32_t query) {
+void gfxstream_vk_CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+ VkQueryPool queryPool, uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage,
- VkQueryPool queryPool, uint32_t query) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdWriteTimestamp2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteTimestamp2KHR(gfxstream_commandBuffer->internal_object, stage,
+ gfxstream_queryPool->internal_object, query,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
}
-static VkResult entry_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit2KHR");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
- vkQueueSubmit2KHR_VkResult_return =
- vkEnc->vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+ std::vector<std::vector<VkCommandBufferSubmitInfo>>
+ internal_VkSubmitInfo2_pCommandBufferInfos;
+ std::vector<std::vector<VkSemaphoreSubmitInfo>>
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo2::pWaitSemaphoreInfos */
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+ internal_pSubmits[i].waitSemaphoreInfoCount);
+ internal_pSubmits[i].pWaitSemaphoreInfos =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+ internal_pSubmits[i].waitSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+ /* VkSubmitInfo2::pCommandBufferInfos */
+ internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+ std::vector<VkCommandBufferSubmitInfo>());
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+ internal_pSubmits[i].commandBufferInfoCount);
+ memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+ sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+ internal_pSubmits[i].pCommandBufferInfos[j];
+ /* VkCommandBufferSubmitInfo::commandBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+ gfxstream_commandBuffer->internal_object;
+ }
+ internal_pSubmits[i].pCommandBufferInfos =
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+ /* VkSubmitInfo2::pSignalSemaphoreInfos */
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+ internal_pSubmits[i].signalSemaphoreInfoCount);
+ internal_pSubmits[i].pSignalSemaphoreInfos =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+ internal_pSubmits[i].signalSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+ }
+ vkQueueSubmit2KHR_VkResult_return = vkEnc->vkQueueSubmit2KHR(
+ gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
return vkQueueSubmit2KHR_VkResult_return;
}
-static void entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, uint32_t marker) {
+void gfxstream_vk_CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, uint32_t marker) {
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage,
- VkBuffer dstBuffer, VkDeviceSize dstOffset,
- uint32_t marker) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdWriteBufferMarker2AMD", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteBufferMarker2AMD(gfxstream_commandBuffer->internal_object, stage,
+ gfxstream_dstBuffer->internal_object, dstOffset, marker,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
- true /* do lock */);
}
-static void entry_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData) {
+void gfxstream_vk_GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointData2NV* pCheckpointData) {
AEMU_SCOPED_TRACE("vkGetQueueCheckpointData2NV");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkGetQueueCheckpointData2NV(gfxstream_queue->internal_object, pCheckpointDataCount,
+ pCheckpointData, true /* do lock */);
+ }
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
#endif
#ifdef VK_KHR_copy_commands2
-static void entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
+void gfxstream_vk_CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2* pCopyBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyBuffer2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
+ /* VkCopyBufferInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferInfo[i].srcBuffer);
+ internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyBufferInfo[i].dstBuffer);
+ internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyBuffer2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
}
-static void entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
+void gfxstream_vk_CmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2* pCopyImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageInfo[i] = pCopyImageInfo[i];
+ /* VkCopyImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageInfo[i].srcImage);
+ internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyImageInfo[i].dstImage);
+ internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
}
-static void entry_vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+void gfxstream_vk_CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyBufferToImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
+ /* VkCopyBufferToImageInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferToImageInfo[i].srcBuffer);
+ internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferToImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyBufferToImageInfo[i].dstImage);
+ internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyBufferToImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferToImageInfo.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
}
-static void entry_vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+void gfxstream_vk_CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyImageToBuffer2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
+ /* VkCopyImageToBufferInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToBufferInfo[i].srcImage);
+ internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageToBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyImageToBufferInfo[i].dstBuffer);
+ internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyImageToBuffer2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageToBufferInfo.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
}
-static void entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
+void gfxstream_vk_CmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2* pBlitImageInfo) {
AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBlitImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBlitImageInfo[i] = pBlitImageInfo[i];
+ /* VkBlitImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pBlitImageInfo[i].srcImage);
+ internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkBlitImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pBlitImageInfo[i].dstImage);
+ internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdBlitImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pBlitImageInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
}
-static void entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
+void gfxstream_vk_CmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2* pResolveImageInfo) {
AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdResolveImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pResolveImageInfo[i] = pResolveImageInfo[i];
+ /* VkResolveImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pResolveImageInfo[i].srcImage);
+ internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkResolveImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pResolveImageInfo[i].dstImage);
+ internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdResolveImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pResolveImageInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
}
#endif
#ifdef VK_KHR_format_feature_flags2
#endif
#ifdef VK_KHR_maintenance4
-static void entry_vkGetDeviceBufferMemoryRequirementsKHR(
+void gfxstream_vk_GetDeviceBufferMemoryRequirementsKHR(
VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR(
- VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirementsKHR",
- "VK_KHR_maintenance4");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetDeviceImageMemoryRequirementsKHR(VkDevice device,
+ const VkDeviceImageMemoryRequirements* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirementsKHR",
- "VK_KHR_maintenance4");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
+void gfxstream_vk_GetDeviceImageSparseMemoryRequirementsKHR(
VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirementsKHR",
- "VK_KHR_maintenance4");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(
+ gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements,
- true /* do lock */);
}
#endif
#ifdef VK_KHR_maintenance5
-static void entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkDeviceSize size,
- VkIndexType indexType) {
+void gfxstream_vk_CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkDeviceSize size,
+ VkIndexType indexType) {
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkDeviceSize size,
- VkIndexType indexType) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindIndexBuffer2KHR", "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindIndexBuffer2KHR(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, size, indexType,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
- true /* do lock */);
}
-static void entry_vkGetRenderingAreaGranularityKHR(VkDevice device,
- const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
- VkExtent2D* pGranularity) {
+void gfxstream_vk_GetRenderingAreaGranularityKHR(VkDevice device,
+ const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+ VkExtent2D* pGranularity) {
AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetRenderingAreaGranularityKHR(
- VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkGetRenderingAreaGranularityKHR", "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetRenderingAreaGranularityKHR(gfxstream_device->internal_object,
+ pRenderingAreaInfo, pGranularity,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
- const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetDeviceImageSubresourceLayoutKHR(VkDevice device,
+ const VkDeviceImageSubresourceInfoKHR* pInfo,
+ VkSubresourceLayout2KHR* pLayout) {
AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR(
- VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSubresourceLayoutKHR",
- "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageSubresourceLayoutKHR(gfxstream_device->internal_object, pInfo,
+ pLayout, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
}
-static void entry_vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
+ const VkImageSubresource2KHR* pSubresource,
+ VkSubresourceLayout2KHR* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSubresourceLayout2KHR(
- VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2KHR", "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSubresourceLayout2KHR(gfxstream_device->internal_object,
+ gfxstream_image->internal_object, pSubresource,
+ pLayout, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
- true /* do lock */);
}
#endif
#ifdef VK_ANDROID_native_buffer
-static VkResult entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage) {
+VkResult gfxstream_vk_GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage) {
AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
- device, format, imageUsage, grallocUsage, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetSwapchainGrallocUsageANDROID_VkResult_return =
+ vkEnc->vkGetSwapchainGrallocUsageANDROID(gfxstream_device->internal_object, format,
+ imageUsage, grallocUsage, true /* do lock */);
+ }
return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsageANDROID",
- "VK_ANDROID_native_buffer");
- }
- AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
- device, format, imageUsage, grallocUsage, true /* do lock */);
- return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
-}
-static VkResult entry_vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
- VkSemaphore semaphore, VkFence fence) {
+VkResult gfxstream_vk_AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
+ VkSemaphore semaphore, VkFence fence) {
AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
- vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
- device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
+ gfxstream_device->internal_object, gfxstream_image->internal_object, nativeFenceFd,
+ gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
return vkAcquireImageANDROID_VkResult_return;
}
-static VkResult dynCheck_entry_vkAcquireImageANDROID(VkDevice device, VkImage image,
- int nativeFenceFd, VkSemaphore semaphore,
- VkFence fence) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkAcquireImageANDROID", "VK_ANDROID_native_buffer");
- }
- AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
- vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
- device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
- return vkAcquireImageANDROID_VkResult_return;
-}
-static VkResult entry_vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image, int* pNativeFenceFd) {
+VkResult gfxstream_vk_QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image, int* pNativeFenceFd) {
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueSignalReleaseImageANDROID_VkResult_return =
- resources->on_vkQueueSignalReleaseImageANDROID(vkEnc, VK_SUCCESS, queue, waitSemaphoreCount,
- pWaitSemaphores, image, pNativeFenceFd);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
+ for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+ if (pWaitSemaphores) {
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
+ pWaitSemaphores[i]);
+ internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueSignalReleaseImageANDROID_VkResult_return =
+ resources->on_vkQueueSignalReleaseImageANDROID(
+ vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, waitSemaphoreCount,
+ internal_pWaitSemaphores.data(), gfxstream_image->internal_object, pNativeFenceFd);
+ }
return vkQueueSignalReleaseImageANDROID_VkResult_return;
}
-static VkResult entry_vkGetSwapchainGrallocUsage2ANDROID(
+VkResult gfxstream_vk_GetSwapchainGrallocUsage2ANDROID(
VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
uint64_t* grallocProducerUsage) {
AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
- device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
- true /* do lock */);
- return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID(
- VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
- VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
- uint64_t* grallocProducerUsage) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsage2ANDROID",
- "VK_ANDROID_native_buffer");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetSwapchainGrallocUsage2ANDROID_VkResult_return =
+ vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
+ gfxstream_device->internal_object, format, imageUsage, swapchainImageUsage,
+ grallocConsumerUsage, grallocProducerUsage, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
- device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
- true /* do lock */);
return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
}
#endif
#ifdef VK_EXT_transform_feedback
-static void entry_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding, uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes) {
+void gfxstream_vk_CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstBinding, uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets,
+ const VkDeviceSize* pSizes) {
AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
- pOffsets, pSizes, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT(
- VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
- const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindTransformFeedbackBuffersEXT",
- "VK_EXT_transform_feedback");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ vkEnc->vkCmdBindTransformFeedbackBuffersEXT(
+ gfxstream_commandBuffer->internal_object, firstBinding, bindingCount,
+ internal_pBuffers.data(), pOffsets, pSizes, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
- pOffsets, pSizes, true /* do lock */);
}
-static void entry_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets) {
- AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginTransformFeedbackEXT(
- VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginTransformFeedbackEXT",
- "VK_EXT_transform_feedback");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets,
- true /* do lock */);
-}
-static void entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+void gfxstream_vk_CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers,
const VkDeviceSize* pCounterBufferOffsets) {
+ AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
+ for (uint32_t i = 0; i < counterBufferCount; ++i) {
+ if (pCounterBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
+ internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBeginTransformFeedbackEXT(
+ gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
+ internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers,
+ const VkDeviceSize* pCounterBufferOffsets) {
AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndTransformFeedbackEXT",
- "VK_EXT_transform_feedback");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
+ for (uint32_t i = 0; i < counterBufferCount; ++i) {
+ if (pCounterBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
+ internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdEndTransformFeedbackEXT(
+ gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
+ internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
}
-static void entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, VkQueryControlFlags flags,
- uint32_t index) {
+void gfxstream_vk_CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags,
+ uint32_t index) {
AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,
- VkQueryPool queryPool, uint32_t query,
- VkQueryControlFlags flags, uint32_t index) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginQueryIndexedEXT", "VK_EXT_transform_feedback");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
- true /* do lock */);
-}
-static void entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, uint32_t index) {
- AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,
- VkQueryPool queryPool, uint32_t query,
- uint32_t index) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndQueryIndexedEXT", "VK_EXT_transform_feedback");
- }
- AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
-}
-static void entry_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
- uint32_t instanceCount, uint32_t firstInstance,
- VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset, uint32_t vertexStride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
- counterBufferOffset, counterOffset, vertexStride,
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBeginQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, flags, index,
true /* do lock */);
-}
-static void dynCheck_entry_vkCmdDrawIndirectByteCountEXT(
- VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance,
- VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset,
- uint32_t vertexStride) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectByteCountEXT",
- "VK_EXT_transform_feedback");
}
+}
+void gfxstream_vk_CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, uint32_t index) {
+ AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, index,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+ uint32_t firstInstance, VkBuffer counterBuffer,
+ VkDeviceSize counterBufferOffset,
+ uint32_t counterOffset, uint32_t vertexStride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
- counterBufferOffset, counterOffset, vertexStride,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_counterBuffer, counterBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndirectByteCountEXT(
+ gfxstream_commandBuffer->internal_object, instanceCount, firstInstance,
+ gfxstream_counterBuffer->internal_object, counterBufferOffset, counterOffset,
+ vertexStride, true /* do lock */);
+ }
}
#endif
#ifdef VK_AMD_gpu_shader_half_float
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -3621,62 +5252,42 @@
#ifdef VK_EXT_debug_utils
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
+VkResult gfxstream_vk_GetAndroidHardwareBufferPropertiesANDROID(
VkDevice device, const AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
- resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
- pProperties);
- return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID(
- VkDevice device, const AHardwareBuffer* buffer,
- VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device,
- "VK_ANDROID_external_memory_android_hardware_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetAndroidHardwareBufferPropertiesANDROID",
- "VK_ANDROID_external_memory_android_hardware_buffer");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
+ resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, buffer, pProperties);
}
- AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
- vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
- resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
- pProperties);
return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
}
-static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
+VkResult gfxstream_vk_GetMemoryAndroidHardwareBufferANDROID(
VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
AHardwareBuffer** pBuffer) {
AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
- resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
- pBuffer);
- return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID(
- VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
- AHardwareBuffer** pBuffer) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device,
- "VK_ANDROID_external_memory_android_hardware_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryAndroidHardwareBufferANDROID",
- "VK_ANDROID_external_memory_android_hardware_buffer");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkMemoryGetAndroidHardwareBufferInfoANDROID> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkMemoryGetAndroidHardwareBufferInfoANDROID::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+ internal_pInfo[i].memory = gfxstream_memory->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
+ resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS,
+ gfxstream_device->internal_object,
+ internal_pInfo.data(), pBuffer);
}
- AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
- vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
- resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
- pBuffer);
return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
}
#endif
@@ -3697,402 +5308,283 @@
#ifdef VK_EXT_subgroup_size_control
#endif
#ifdef VK_EXT_tooling_info
-static VkResult entry_vkGetPhysicalDeviceToolPropertiesEXT(
+VkResult gfxstream_vk_GetPhysicalDeviceToolPropertiesEXT(
VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
VkPhysicalDeviceToolProperties* pToolProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolPropertiesEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
- vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(gfxstream_physicalDevice->internal_object,
+ pToolCount, pToolProperties,
+ true /* do lock */);
+ }
return vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return;
}
#endif
#ifdef VK_EXT_provoking_vertex
#endif
#ifdef VK_EXT_line_rasterization
-static void entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
- uint16_t lineStipplePattern) {
+void gfxstream_vk_CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern) {
AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,
- uint32_t lineStippleFactor,
- uint16_t lineStipplePattern) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_line_rasterization")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetLineStippleEXT", "VK_EXT_line_rasterization");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetLineStippleEXT(gfxstream_commandBuffer->internal_object, lineStippleFactor,
+ lineStipplePattern, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_index_type_uint8
#endif
#ifdef VK_EXT_extended_dynamic_state
-static void entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+void gfxstream_vk_CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,
- VkCullModeFlags cullMode) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetCullModeEXT", "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetCullModeEXT(gfxstream_commandBuffer->internal_object, cullMode,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
}
-static void entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+void gfxstream_vk_CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,
- VkFrontFace frontFace) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetFrontFaceEXT", "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetFrontFaceEXT(gfxstream_commandBuffer->internal_object, frontFace,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
}
-static void entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
+void gfxstream_vk_CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveTopologyEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveTopologyEXT(gfxstream_commandBuffer->internal_object,
+ primitiveTopology, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
}
-static void entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+ const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWithCountEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetViewportWithCountEXT(gfxstream_commandBuffer->internal_object, viewportCount,
+ pViewports, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
- true /* do lock */);
}
-static void entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
- const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+ const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,
- uint32_t scissorCount,
- const VkRect2D* pScissors) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetScissorWithCountEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetScissorWithCountEXT(gfxstream_commandBuffer->internal_object, scissorCount,
+ pScissors, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
}
-static void entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
+void gfxstream_vk_CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides) {
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- pSizes, pStrides, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding, uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindVertexBuffers2EXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ if (pBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBindVertexBuffers2EXT(gfxstream_commandBuffer->internal_object, firstBinding,
+ bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
+ pStrides, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- pSizes, pStrides, true /* do lock */);
}
-static void entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable) {
+void gfxstream_vk_CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthTestEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthTestEnableEXT(gfxstream_commandBuffer->internal_object, depthTestEnable,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
}
-static void entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable) {
+void gfxstream_vk_CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthWriteEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthWriteEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthWriteEnableEXT(gfxstream_commandBuffer->internal_object,
+ depthWriteEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
}
-static void entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp) {
+void gfxstream_vk_CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
+ VkCompareOp depthCompareOp) {
AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthCompareOpEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthCompareOpEXT(gfxstream_commandBuffer->internal_object, depthCompareOp,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
}
-static void entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
+void gfxstream_vk_CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBoundsTestEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBoundsTestEnableEXT(gfxstream_commandBuffer->internal_object,
+ depthBoundsTestEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
- true /* do lock */);
}
-static void entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
+void gfxstream_vk_CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 stencilTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilTestEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilTestEnableEXT(gfxstream_commandBuffer->internal_object,
+ stencilTestEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
}
-static void entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- VkStencilOp failOp, VkStencilOp passOp,
- VkStencilOp depthFailOp, VkCompareOp compareOp) {
+void gfxstream_vk_CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ VkStencilOp failOp, VkStencilOp passOp,
+ VkStencilOp depthFailOp, VkCompareOp compareOp) {
AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, VkStencilOp failOp,
- VkStencilOp passOp, VkStencilOp depthFailOp,
- VkCompareOp compareOp) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilOpEXT", "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilOpEXT(gfxstream_commandBuffer->internal_object, faceMask, failOp,
+ passOp, depthFailOp, compareOp, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_host_image_copy
-static VkResult entry_vkCopyMemoryToImageEXT(
+VkResult gfxstream_vk_CopyMemoryToImageEXT(
VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
- vkCopyMemoryToImageEXT_VkResult_return =
- vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkCopyMemoryToImageInfoEXT> internal_pCopyMemoryToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyMemoryToImageInfo[i] = pCopyMemoryToImageInfo[i];
+ /* VkCopyMemoryToImageInfoEXT::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyMemoryToImageInfo[i].dstImage);
+ internal_pCopyMemoryToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkCopyMemoryToImageEXT_VkResult_return = vkEnc->vkCopyMemoryToImageEXT(
+ gfxstream_device->internal_object, internal_pCopyMemoryToImageInfo.data(),
+ true /* do lock */);
+ }
return vkCopyMemoryToImageEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCopyMemoryToImageEXT(
- VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkCopyMemoryToImageEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
- vkCopyMemoryToImageEXT_VkResult_return =
- vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
- return vkCopyMemoryToImageEXT_VkResult_return;
-}
-static VkResult entry_vkCopyImageToMemoryEXT(
+VkResult gfxstream_vk_CopyImageToMemoryEXT(
VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
- vkCopyImageToMemoryEXT_VkResult_return =
- vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkCopyImageToMemoryInfoEXT> internal_pCopyImageToMemoryInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToMemoryInfo[i] = pCopyImageToMemoryInfo[i];
+ /* VkCopyImageToMemoryInfoEXT::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToMemoryInfo[i].srcImage);
+ internal_pCopyImageToMemoryInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ }
+ vkCopyImageToMemoryEXT_VkResult_return = vkEnc->vkCopyImageToMemoryEXT(
+ gfxstream_device->internal_object, internal_pCopyImageToMemoryInfo.data(),
+ true /* do lock */);
+ }
return vkCopyImageToMemoryEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCopyImageToMemoryEXT(
- VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkCopyImageToMemoryEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
- vkCopyImageToMemoryEXT_VkResult_return =
- vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
- return vkCopyImageToMemoryEXT_VkResult_return;
-}
-static VkResult entry_vkCopyImageToImageEXT(
- VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
+VkResult gfxstream_vk_CopyImageToImageEXT(VkDevice device,
+ const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
- vkCopyImageToImageEXT_VkResult_return =
- vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkCopyImageToImageInfoEXT> internal_pCopyImageToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToImageInfo[i] = pCopyImageToImageInfo[i];
+ /* VkCopyImageToImageInfoEXT::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToImageInfo[i].srcImage);
+ internal_pCopyImageToImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageToImageInfoEXT::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyImageToImageInfo[i].dstImage);
+ internal_pCopyImageToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkCopyImageToImageEXT_VkResult_return =
+ vkEnc->vkCopyImageToImageEXT(gfxstream_device->internal_object,
+ internal_pCopyImageToImageInfo.data(), true /* do lock */);
+ }
return vkCopyImageToImageEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCopyImageToImageEXT(
- VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkCopyImageToImageEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
- vkCopyImageToImageEXT_VkResult_return =
- vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
- return vkCopyImageToImageEXT_VkResult_return;
-}
-static VkResult entry_vkTransitionImageLayoutEXT(
+VkResult gfxstream_vk_TransitionImageLayoutEXT(
VkDevice device, uint32_t transitionCount,
const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
- vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
- device, transitionCount, pTransitions, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkHostImageLayoutTransitionInfoEXT> internal_pTransitions(transitionCount);
+ for (uint32_t i = 0; i < transitionCount; ++i) {
+ internal_pTransitions[i] = pTransitions[i];
+ /* VkHostImageLayoutTransitionInfoEXT::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pTransitions[i].image);
+ internal_pTransitions[i].image = gfxstream_image->internal_object;
+ }
+ vkTransitionImageLayoutEXT_VkResult_return =
+ vkEnc->vkTransitionImageLayoutEXT(gfxstream_device->internal_object, transitionCount,
+ internal_pTransitions.data(), true /* do lock */);
+ }
return vkTransitionImageLayoutEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkTransitionImageLayoutEXT(
- VkDevice device, uint32_t transitionCount,
- const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkTransitionImageLayoutEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
- vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
- device, transitionCount, pTransitions, true /* do lock */);
- return vkTransitionImageLayoutEXT_VkResult_return;
-}
-static void entry_vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
+ const VkImageSubresource2KHR* pSubresource,
+ VkSubresourceLayout2KHR* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSubresourceLayout2EXT(
- VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2EXT",
- "VK_EXT_host_image_copy");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSubresourceLayout2EXT(gfxstream_device->internal_object,
+ gfxstream_image->internal_object, pSubresource,
+ pLayout, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_swapchain_maintenance1
@@ -4106,92 +5598,54 @@
#ifdef VK_EXT_custom_border_color
#endif
#ifdef VK_EXT_private_data
-static VkResult entry_vkCreatePrivateDataSlotEXT(VkDevice device,
- const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlot* pPrivateDataSlot) {
+VkResult gfxstream_vk_CreatePrivateDataSlotEXT(VkDevice device,
+ const VkPrivateDataSlotCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPrivateDataSlot* pPrivateDataSlot) {
AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreatePrivateDataSlotEXT_VkResult_return =
+ vkEnc->vkCreatePrivateDataSlotEXT(gfxstream_device->internal_object, pCreateInfo,
+ pAllocator, pPrivateDataSlot, true /* do lock */);
+ }
return vkCreatePrivateDataSlotEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreatePrivateDataSlotEXT(
- VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlotEXT", "VK_EXT_private_data");
- }
- AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
- return vkCreatePrivateDataSlotEXT_VkResult_return;
-}
-static void entry_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyPrivateDataSlotEXT(VkDevice device,
- VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlotEXT", "VK_EXT_private_data");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPrivateDataSlotEXT(gfxstream_device->internal_object, privateDataSlot,
+ pAllocator, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
}
-static VkResult entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
+VkResult gfxstream_vk_SetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+ uint64_t data) {
AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
- vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkSetPrivateDataEXT_VkResult_return =
+ vkEnc->vkSetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, data, true /* do lock */);
+ }
return vkSetPrivateDataEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkSetPrivateDataEXT", "VK_EXT_private_data");
- }
- AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
- vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
- return vkSetPrivateDataEXT_VkResult_return;
-}
-static void entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t* pData) {
+void gfxstream_vk_GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+ VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPrivateDataEXT", "VK_EXT_private_data");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, pData, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
@@ -4209,129 +5663,78 @@
#ifdef VK_EXT_primitive_topology_list_restart
#endif
#ifdef VK_EXT_extended_dynamic_state2
-static void entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints) {
+void gfxstream_vk_CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
+ uint32_t patchControlPoints) {
AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPatchControlPointsEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPatchControlPointsEXT(gfxstream_commandBuffer->internal_object,
+ patchControlPoints, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
}
-static void entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
+void gfxstream_vk_CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable) {
AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetRasterizerDiscardEnableEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetRasterizerDiscardEnableEXT(gfxstream_commandBuffer->internal_object,
+ rasterizerDiscardEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
- true /* do lock */);
}
-static void entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable) {
+void gfxstream_vk_CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBiasEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBiasEnableEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBiasEnableEXT(gfxstream_commandBuffer->internal_object, depthBiasEnable,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
}
-static void entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
+void gfxstream_vk_CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetLogicOpEXT", "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetLogicOpEXT(gfxstream_commandBuffer->internal_object, logicOp,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
}
-static void entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
+void gfxstream_vk_CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveRestartEnableEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveRestartEnableEXT(gfxstream_commandBuffer->internal_object,
+ primitiveRestartEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
- true /* do lock */);
}
#endif
#ifdef VK_GOOGLE_gfxstream
-static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
- uint64_t* pAddress) {
+VkResult gfxstream_vk_MapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress) {
AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
- vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
- vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
- return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkMapMemoryIntoAddressSpaceGOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
+ vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(gfxstream_device->internal_object,
+ gfxstream_memory->internal_object, pAddress,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
- vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
- vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
}
-static void entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateSizedGOOGLE(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
@@ -4339,228 +5742,468 @@
const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
const VkBufferView* pBufferViews) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
- pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
- uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSizedGOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
+ for (uint32_t i = 0; i < imageInfoCount; ++i) {
+ if (pImageInfos) {
+ internal_pImageInfos[i] = pImageInfos[i];
+ /* VkDescriptorImageInfo::imageView */
+ if (internal_pImageInfos[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_pImageInfos[i].imageView);
+ internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
+ }
+ }
+ }
+ std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
+ for (uint32_t i = 0; i < bufferInfoCount; ++i) {
+ if (pBufferInfos) {
+ internal_pBufferInfos[i] = pBufferInfos[i];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_pBufferInfos[i].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferInfos[i].buffer);
+ internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
+ for (uint32_t i = 0; i < bufferViewCount; ++i) {
+ if (pBufferViews) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
+ internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
+ }
+ }
+ vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+ gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
+ bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
+ pBufferViewEntryIndices, internal_pImageInfos.data(), internal_pBufferInfos.data(),
+ internal_pBufferViews.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
- pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
}
-static void entry_vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo) {
+void gfxstream_vk_BeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo) {
AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
+ std::vector<VkCommandBufferInheritanceInfo>
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBeginInfo[i] = pBeginInfo[i];
+ /* VkCommandBufferBeginInfo::pInheritanceInfo */
+ if (internal_pBeginInfo[i].pInheritanceInfo) {
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
+ internal_pBeginInfo[i].pInheritanceInfo[0];
+ /* VkCommandBufferInheritanceInfo::renderPass */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
+ gfxstream_renderPass->internal_object;
+ }
+ /* VkCommandBufferInheritanceInfo::framebuffer */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
+ gfxstream_framebuffer->internal_object;
+ }
+ internal_pBeginInfo[i].pInheritanceInfo =
+ &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
+ }
+ }
+ vkEnc->vkBeginCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
+ internal_pBeginInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_EndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkEndCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
+ true /* do lock */);
+ }
}
-static void entry_vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags) {
+void gfxstream_vk_ResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkResetCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object, flags,
+ true /* do lock */);
+ }
}
-static void entry_vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer,
- uint32_t needHostSync, uint32_t sequenceNumber) {
+void gfxstream_vk_CommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t needHostSync,
+ uint32_t sequenceNumber) {
AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber,
- true /* do lock */);
-}
-static VkResult entry_vkCreateImageWithRequirementsGOOGLE(
- VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
- VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateImageWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
- pMemoryRequirements, true /* do lock */);
- return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateImageWithRequirementsGOOGLE(
- VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
- VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateImageWithRequirementsGOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCommandBufferHostSyncGOOGLE(gfxstream_commandBuffer->internal_object, needHostSync,
+ sequenceNumber, true /* do lock */);
}
+}
+VkResult gfxstream_vk_CreateImageWithRequirementsGOOGLE(VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
vkCreateImageWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
- pMemoryRequirements, true /* do lock */);
+ gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateImageWithRequirementsGOOGLE_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateImageWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateImageWithRequirementsGOOGLE(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pImage->internal_object, pMemoryRequirements, true /* do lock */);
+ }
+ *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
}
-static VkResult entry_vkCreateBufferWithRequirementsGOOGLE(
+VkResult gfxstream_vk_CreateBufferWithRequirementsGOOGLE(
VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
- pMemoryRequirements, true /* do lock */);
+ gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateBufferWithRequirementsGOOGLE_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateBufferWithRequirementsGOOGLE(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pBuffer->internal_object, pMemoryRequirements, true /* do lock */);
+ }
+ *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE(
- VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateBufferWithRequirementsGOOGLE",
- "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
- pMemoryRequirements, true /* do lock */);
- return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
-}
-static VkResult entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
- uint64_t* pAddress, uint64_t* pSize,
- uint64_t* pHostmemId) {
+VkResult gfxstream_vk_GetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress, uint64_t* pSize,
+ uint64_t* pHostmemId) {
AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
- vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
- device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
+ gfxstream_device->internal_object, gfxstream_memory->internal_object, pAddress, pSize,
+ pHostmemId, true /* do lock */);
+ }
return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress, uint64_t* pSize,
- uint64_t* pHostmemId) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostAddressInfoGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
- vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
- device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
- return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
-}
-static VkResult entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
+VkResult gfxstream_vk_FreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
- vkFreeMemorySyncGOOGLE_VkResult_return =
- vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == memory) {
+ return vkFreeMemorySyncGOOGLE_VkResult_return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkFreeMemorySyncGOOGLE_VkResult_return = vkEnc->vkFreeMemorySyncGOOGLE(
+ gfxstream_device->internal_object,
+ gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
return vkFreeMemorySyncGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkFreeMemorySyncGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
- vkFreeMemorySyncGOOGLE_VkResult_return =
- vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
- return vkFreeMemorySyncGOOGLE_VkResult_return;
-}
-static void entry_vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
- uint32_t sequenceNumber) {
+void gfxstream_vk_QueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
+ uint32_t sequenceNumber) {
AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueHostSyncGOOGLE(queue, needHostSync, sequenceNumber, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueHostSyncGOOGLE(gfxstream_queue->internal_object, needHostSync, sequenceNumber,
+ true /* do lock */);
+ }
}
-static void entry_vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo* pSubmits, VkFence fence) {
+void gfxstream_vk_QueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
+ std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo::pWaitSemaphores */
+ internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
+ internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
+ internal_pSubmits[i].waitSemaphoreCount =
+ internal_VkSubmitInfo_pWaitSemaphores[i].size();
+ /* VkSubmitInfo::pCommandBuffers */
+ internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
+ internal_VkSubmitInfo_pCommandBuffers[i].reserve(
+ internal_pSubmits[i].commandBufferCount);
+ memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
+ sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+ internal_pSubmits[i].pCommandBuffers[j]);
+ internal_VkSubmitInfo_pCommandBuffers[i][j] =
+ gfxstream_pCommandBuffers->internal_object;
+ }
+ internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
+ /* VkSubmitInfo::pSignalSemaphores */
+ internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
+ internal_pSubmits[i].pSignalSemaphores =
+ internal_VkSubmitInfo_pSignalSemaphores[i].data();
+ internal_pSubmits[i].signalSemaphoreCount =
+ internal_VkSubmitInfo_pSignalSemaphores[i].size();
+ }
+ vkEnc->vkQueueSubmitAsyncGOOGLE(
+ gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
}
-static void entry_vkQueueWaitIdleAsyncGOOGLE(VkQueue queue) {
+void gfxstream_vk_QueueWaitIdleAsyncGOOGLE(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueWaitIdleAsyncGOOGLE(queue, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueWaitIdleAsyncGOOGLE(gfxstream_queue->internal_object, true /* do lock */);
+ }
}
-static void entry_vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo, VkFence fence) {
+void gfxstream_vk_QueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueBindSparseAsyncGOOGLE(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
-}
-static void entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayoutGOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
+ std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
+ internal_VkBindSparseInfo_pBufferBinds;
+ std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
+ internal_VkBindSparseInfo_pImageOpaqueBinds;
+ std::vector<std::vector<VkSparseMemoryBind>>
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
+ std::vector<std::vector<VkSparseImageMemoryBind>>
+ internal_VkSparseImageMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfo[i] = pBindInfo[i];
+ /* VkBindSparseInfo::pWaitSemaphores */
+ internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
+ internal_pBindInfo[i].pWaitSemaphores =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].data();
+ internal_pBindInfo[i].waitSemaphoreCount =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].size();
+ /* VkBindSparseInfo::pBufferBinds */
+ internal_VkBindSparseInfo_pBufferBinds.push_back(
+ std::vector<VkSparseBufferMemoryBindInfo>());
+ internal_VkBindSparseInfo_pBufferBinds[i].reserve(
+ internal_pBindInfo[i].bufferBindCount);
+ memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
+ sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
+ internal_VkBindSparseInfo_pBufferBinds[i][j] =
+ internal_pBindInfo[i].pBufferBinds[j];
+ /* VkSparseBufferMemoryBindInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ /* VkSparseBufferMemoryBindInfo::pBinds */
+ internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
+ ++k) {
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
+ /* VkBindSparseInfo::pImageOpaqueBinds */
+ internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
+ std::vector<VkSparseImageOpaqueMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
+ sizeof(VkSparseImageOpaqueMemoryBindInfo) *
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
+ internal_pBindInfo[i].pImageOpaqueBinds[j];
+ /* VkSparseImageOpaqueMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ for (uint32_t l = 0;
+ l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageOpaqueBinds =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
+ /* VkBindSparseInfo::pImageBinds */
+ internal_VkBindSparseInfo_pImageBinds.push_back(
+ std::vector<VkSparseImageMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
+ memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
+ sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
+ /* VkSparseImageMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageMemoryBindInfo::pBinds */
+ internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseImageMemoryBind>());
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseImageMemoryBind) *
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
+ ++m) {
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
+ /* VkSparseImageMemoryBind::memory */
+ if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
+ /* VkBindSparseInfo::pSignalSemaphores */
+ internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pSignalSemaphores[i] =
+ transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
+ internal_pBindInfo[i].signalSemaphoreCount);
+ internal_pBindInfo[i].pSignalSemaphores =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].data();
+ internal_pBindInfo[i].signalSemaphoreCount =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].size();
+ }
+ vkEnc->vkQueueBindSparseAsyncGOOGLE(
+ gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
}
+}
+void gfxstream_vk_GetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
- true /* do lock */);
-}
-static void entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayout2GOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetLinearImageLayoutGOOGLE(gfxstream_device->internal_object, format, pOffset,
+ pRowPitchAlignment, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
- true /* do lock */);
}
-static void entry_vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
- VkDeviceSize dataSize, const void* pData) {
+void gfxstream_vk_GetLinearImageLayout2GOOGLE(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
+ AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetLinearImageLayout2GOOGLE(gfxstream_device->internal_object, pCreateInfo,
+ pOffset, pRowPitchAlignment, true /* do lock */);
+ }
+}
+void gfxstream_vk_QueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
+ VkDeviceSize dataSize, const void* pData) {
AEMU_SCOPED_TRACE("vkQueueFlushCommandsGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueFlushCommandsGOOGLE(queue, commandBuffer, dataSize, pData, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueFlushCommandsGOOGLE(gfxstream_queue->internal_object,
+ gfxstream_commandBuffer->internal_object, dataSize, pData,
+ true /* do lock */);
+ }
}
-static void entry_vkQueueCommitDescriptorSetUpdatesGOOGLE(
+void gfxstream_vk_QueueCommitDescriptorSetUpdatesGOOGLE(
VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
@@ -4568,71 +6211,166 @@
const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
const VkWriteDescriptorSet* pPendingDescriptorWrites) {
AEMU_SCOPED_TRACE("vkQueueCommitDescriptorSetUpdatesGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
- queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount, pSetLayouts,
- pDescriptorSetPoolIds, pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
- pDescriptorWriteStartingIndices, pendingDescriptorWriteCount, pPendingDescriptorWrites,
- true /* do lock */);
-}
-static void entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
- AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount,
- uint64_t* pPoolIds) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkCollectDescriptorPoolIdsGOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkDescriptorPool> internal_pDescriptorPools(descriptorPoolCount);
+ for (uint32_t i = 0; i < descriptorPoolCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_pDescriptorPools,
+ pDescriptorPools[i]);
+ internal_pDescriptorPools[i] = gfxstream_pDescriptorPools->internal_object;
+ }
+ std::vector<VkDescriptorSetLayout> internal_pSetLayouts(descriptorSetCount);
+ for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+ pSetLayouts[i]);
+ internal_pSetLayouts[i] = gfxstream_pSetLayouts->internal_object;
+ }
+ std::vector<VkWriteDescriptorSet> internal_pPendingDescriptorWrites(
+ pendingDescriptorWriteCount);
+ std::vector<std::vector<VkDescriptorImageInfo>> internal_VkWriteDescriptorSet_pImageInfo;
+ std::vector<std::vector<VkDescriptorBufferInfo>> internal_VkWriteDescriptorSet_pBufferInfo;
+ std::vector<std::vector<VkBufferView>> internal_VkWriteDescriptorSet_pTexelBufferView;
+ for (uint32_t i = 0; i < pendingDescriptorWriteCount; ++i) {
+ internal_pPendingDescriptorWrites[i] = pPendingDescriptorWrites[i];
+ /* VkWriteDescriptorSet::pImageInfo */
+ internal_VkWriteDescriptorSet_pImageInfo.push_back(
+ std::vector<VkDescriptorImageInfo>());
+ internal_VkWriteDescriptorSet_pImageInfo[i].reserve(
+ internal_pPendingDescriptorWrites[i].descriptorCount);
+ memset(&internal_VkWriteDescriptorSet_pImageInfo[i][0], 0,
+ sizeof(VkDescriptorImageInfo) *
+ internal_pPendingDescriptorWrites[i].descriptorCount);
+ for (uint32_t j = 0; j < internal_pPendingDescriptorWrites[i].descriptorCount; ++j) {
+ if (internal_pPendingDescriptorWrites[i].pImageInfo) {
+ internal_VkWriteDescriptorSet_pImageInfo[i][j] =
+ internal_pPendingDescriptorWrites[i].pImageInfo[j];
+ /* VkDescriptorImageInfo::imageView */
+ if (internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView);
+ internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ }
+ }
+ internal_pPendingDescriptorWrites[i].pImageInfo =
+ internal_VkWriteDescriptorSet_pImageInfo[i].data();
+ /* VkWriteDescriptorSet::pBufferInfo */
+ internal_VkWriteDescriptorSet_pBufferInfo.push_back(
+ std::vector<VkDescriptorBufferInfo>());
+ internal_VkWriteDescriptorSet_pBufferInfo[i].reserve(
+ internal_pPendingDescriptorWrites[i].descriptorCount);
+ memset(&internal_VkWriteDescriptorSet_pBufferInfo[i][0], 0,
+ sizeof(VkDescriptorBufferInfo) *
+ internal_pPendingDescriptorWrites[i].descriptorCount);
+ for (uint32_t j = 0; j < internal_pPendingDescriptorWrites[i].descriptorCount; ++j) {
+ if (internal_pPendingDescriptorWrites[i].pBufferInfo) {
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j] =
+ internal_pPendingDescriptorWrites[i].pBufferInfo[j];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer);
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ internal_pPendingDescriptorWrites[i].pBufferInfo =
+ internal_VkWriteDescriptorSet_pBufferInfo[i].data();
+ /* VkWriteDescriptorSet::pTexelBufferView */
+ internal_VkWriteDescriptorSet_pTexelBufferView.push_back(std::vector<VkBufferView>());
+ internal_VkWriteDescriptorSet_pTexelBufferView[i].reserve(
+ internal_pPendingDescriptorWrites[i].descriptorCount);
+ memset(&internal_VkWriteDescriptorSet_pTexelBufferView[i][0], 0,
+ sizeof(VkBufferView) * internal_pPendingDescriptorWrites[i].descriptorCount);
+ for (uint32_t j = 0; j < internal_pPendingDescriptorWrites[i].descriptorCount; ++j) {
+ if (internal_pPendingDescriptorWrites[i].pTexelBufferView) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pTexelBufferView,
+ internal_pPendingDescriptorWrites[i].pTexelBufferView[j]);
+ internal_VkWriteDescriptorSet_pTexelBufferView[i][j] =
+ gfxstream_pTexelBufferView->internal_object;
+ }
+ }
+ internal_pPendingDescriptorWrites[i].pTexelBufferView =
+ internal_VkWriteDescriptorSet_pTexelBufferView[i].data();
+ }
+ vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
+ gfxstream_queue->internal_object, descriptorPoolCount, internal_pDescriptorPools.data(),
+ descriptorSetCount, internal_pSetLayouts.data(), pDescriptorSetPoolIds,
+ pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
+ pDescriptorWriteStartingIndices, pendingDescriptorWriteCount,
+ internal_pPendingDescriptorWrites.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
- true /* do lock */);
}
-static void entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image) {
+void gfxstream_vk_CollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
+ AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkCollectDescriptorPoolIdsGOOGLE(gfxstream_device->internal_object,
+ gfxstream_descriptorPool->internal_object,
+ pPoolIdCount, pPoolIds, true /* do lock */);
+ }
+}
+void gfxstream_vk_QueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image) {
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROIDAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue, waitSemaphoreCount, pWaitSemaphores,
- image, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
+ for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+ if (pWaitSemaphores) {
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
+ pWaitSemaphores[i]);
+ internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
+ }
+ }
+ vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
+ gfxstream_queue->internal_object, waitSemaphoreCount, internal_pWaitSemaphores.data(),
+ gfxstream_image->internal_object, true /* do lock */);
+ }
}
-static void entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
- VkCommandBuffer commandBuffer,
- VkDeviceMemory deviceMemory,
- VkDeviceSize dataOffset,
- VkDeviceSize dataSize) {
+void gfxstream_vk_QueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
+ VkCommandBuffer commandBuffer,
+ VkDeviceMemory deviceMemory,
+ VkDeviceSize dataOffset,
+ VkDeviceSize dataSize) {
AEMU_SCOPED_TRACE("vkQueueFlushCommandsFromAuxMemoryGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(queue, commandBuffer, deviceMemory, dataOffset,
- dataSize, true /* do lock */);
-}
-static VkResult entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
- AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
- vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
- return vkGetBlobGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBlobGOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_deviceMemory, deviceMemory);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(
+ gfxstream_queue->internal_object, gfxstream_commandBuffer->internal_object,
+ gfxstream_deviceMemory->internal_object, dataOffset, dataSize, true /* do lock */);
}
+}
+VkResult gfxstream_vk_GetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
- vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetBlobGOOGLE_VkResult_return =
+ vkEnc->vkGetBlobGOOGLE(gfxstream_device->internal_object,
+ gfxstream_memory->internal_object, true /* do lock */);
+ }
return vkGetBlobGOOGLE_VkResult_return;
}
-static void entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateSized2GOOGLE(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
@@ -4641,3600 +6379,116 @@
const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
const uint8_t* pInlineUniformBlockData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
- pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
- true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
- uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
- const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
- const uint8_t* pInlineUniformBlockData) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSized2GOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
+ for (uint32_t i = 0; i < imageInfoCount; ++i) {
+ if (pImageInfos) {
+ internal_pImageInfos[i] = pImageInfos[i];
+ /* VkDescriptorImageInfo::imageView */
+ if (internal_pImageInfos[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_pImageInfos[i].imageView);
+ internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
+ }
+ }
+ }
+ std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
+ for (uint32_t i = 0; i < bufferInfoCount; ++i) {
+ if (pBufferInfos) {
+ internal_pBufferInfos[i] = pBufferInfos[i];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_pBufferInfos[i].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferInfos[i].buffer);
+ internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
+ for (uint32_t i = 0; i < bufferViewCount; ++i) {
+ if (pBufferViews) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
+ internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
+ }
+ }
+ vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+ gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
+ bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices,
+ pBufferInfoEntryIndices, pBufferViewEntryIndices, internal_pImageInfos.data(),
+ internal_pBufferInfos.data(), internal_pBufferViews.data(), pInlineUniformBlockData,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
- pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
- true /* do lock */);
}
-static void entry_vkQueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
+void gfxstream_vk_QueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmitAsync2GOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueSubmitAsync2GOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+ std::vector<std::vector<VkCommandBufferSubmitInfo>>
+ internal_VkSubmitInfo2_pCommandBufferInfos;
+ std::vector<std::vector<VkSemaphoreSubmitInfo>>
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo2::pWaitSemaphoreInfos */
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+ internal_pSubmits[i].waitSemaphoreInfoCount);
+ internal_pSubmits[i].pWaitSemaphoreInfos =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+ internal_pSubmits[i].waitSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+ /* VkSubmitInfo2::pCommandBufferInfos */
+ internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+ std::vector<VkCommandBufferSubmitInfo>());
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+ internal_pSubmits[i].commandBufferInfoCount);
+ memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+ sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+ internal_pSubmits[i].pCommandBufferInfos[j];
+ /* VkCommandBufferSubmitInfo::commandBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+ gfxstream_commandBuffer->internal_object;
+ }
+ internal_pSubmits[i].pCommandBufferInfos =
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+ /* VkSubmitInfo2::pSignalSemaphoreInfos */
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+ internal_pSubmits[i].signalSemaphoreInfoCount);
+ internal_pSubmits[i].pSignalSemaphoreInfos =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+ internal_pSubmits[i].signalSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+ }
+ vkEnc->vkQueueSubmitAsync2GOOGLE(
+ gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
}
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
-void* goldfish_vulkan_get_proc_address(const char* name) {
-#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance")) {
- return (void*)entry_vkCreateInstance;
- }
- if (!strcmp(name, "vkDestroyInstance")) {
- return (void*)entry_vkDestroyInstance;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
- return (void*)entry_vkEnumeratePhysicalDevices;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
- return (void*)entry_vkGetPhysicalDeviceFeatures;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
- return (void*)entry_vkGetPhysicalDeviceProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
- return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
- return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
- }
- if (!strcmp(name, "vkGetInstanceProcAddr")) {
- return (void*)entry_vkGetInstanceProcAddr;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (void*)entry_vkGetDeviceProcAddr;
- }
- if (!strcmp(name, "vkCreateDevice")) {
- return (void*)entry_vkCreateDevice;
- }
- if (!strcmp(name, "vkDestroyDevice")) {
- return (void*)entry_vkDestroyDevice;
- }
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (void*)entry_vkEnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
- return (void*)entry_vkEnumerateDeviceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
- return (void*)entry_vkEnumerateInstanceLayerProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
- return (void*)entry_vkEnumerateDeviceLayerProperties;
- }
- if (!strcmp(name, "vkGetDeviceQueue")) {
- return (void*)entry_vkGetDeviceQueue;
- }
- if (!strcmp(name, "vkQueueSubmit")) {
- return (void*)entry_vkQueueSubmit;
- }
- if (!strcmp(name, "vkQueueWaitIdle")) {
- return (void*)entry_vkQueueWaitIdle;
- }
- if (!strcmp(name, "vkDeviceWaitIdle")) {
- return (void*)entry_vkDeviceWaitIdle;
- }
- if (!strcmp(name, "vkAllocateMemory")) {
- return (void*)entry_vkAllocateMemory;
- }
- if (!strcmp(name, "vkFreeMemory")) {
- return (void*)entry_vkFreeMemory;
- }
- if (!strcmp(name, "vkMapMemory")) {
- return (void*)entry_vkMapMemory;
- }
- if (!strcmp(name, "vkUnmapMemory")) {
- return (void*)entry_vkUnmapMemory;
- }
- if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
- return (void*)entry_vkFlushMappedMemoryRanges;
- }
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
- return (void*)entry_vkInvalidateMappedMemoryRanges;
- }
- if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
- return (void*)entry_vkGetDeviceMemoryCommitment;
- }
- if (!strcmp(name, "vkBindBufferMemory")) {
- return (void*)entry_vkBindBufferMemory;
- }
- if (!strcmp(name, "vkBindImageMemory")) {
- return (void*)entry_vkBindImageMemory;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
- return (void*)entry_vkGetBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements")) {
- return (void*)entry_vkGetImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
- return (void*)entry_vkGetImageSparseMemoryRequirements;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
- }
- if (!strcmp(name, "vkQueueBindSparse")) {
- return (void*)entry_vkQueueBindSparse;
- }
- if (!strcmp(name, "vkCreateFence")) {
- return (void*)entry_vkCreateFence;
- }
- if (!strcmp(name, "vkDestroyFence")) {
- return (void*)entry_vkDestroyFence;
- }
- if (!strcmp(name, "vkResetFences")) {
- return (void*)entry_vkResetFences;
- }
- if (!strcmp(name, "vkGetFenceStatus")) {
- return (void*)entry_vkGetFenceStatus;
- }
- if (!strcmp(name, "vkWaitForFences")) {
- return (void*)entry_vkWaitForFences;
- }
- if (!strcmp(name, "vkCreateSemaphore")) {
- return (void*)entry_vkCreateSemaphore;
- }
- if (!strcmp(name, "vkDestroySemaphore")) {
- return (void*)entry_vkDestroySemaphore;
- }
- if (!strcmp(name, "vkCreateEvent")) {
- return (void*)entry_vkCreateEvent;
- }
- if (!strcmp(name, "vkDestroyEvent")) {
- return (void*)entry_vkDestroyEvent;
- }
- if (!strcmp(name, "vkGetEventStatus")) {
- return (void*)entry_vkGetEventStatus;
- }
- if (!strcmp(name, "vkSetEvent")) {
- return (void*)entry_vkSetEvent;
- }
- if (!strcmp(name, "vkResetEvent")) {
- return (void*)entry_vkResetEvent;
- }
- if (!strcmp(name, "vkCreateQueryPool")) {
- return (void*)entry_vkCreateQueryPool;
- }
- if (!strcmp(name, "vkDestroyQueryPool")) {
- return (void*)entry_vkDestroyQueryPool;
- }
- if (!strcmp(name, "vkGetQueryPoolResults")) {
- return (void*)entry_vkGetQueryPoolResults;
- }
- if (!strcmp(name, "vkCreateBuffer")) {
- return (void*)entry_vkCreateBuffer;
- }
- if (!strcmp(name, "vkDestroyBuffer")) {
- return (void*)entry_vkDestroyBuffer;
- }
- if (!strcmp(name, "vkCreateBufferView")) {
- return (void*)entry_vkCreateBufferView;
- }
- if (!strcmp(name, "vkDestroyBufferView")) {
- return (void*)entry_vkDestroyBufferView;
- }
- if (!strcmp(name, "vkCreateImage")) {
- return (void*)entry_vkCreateImage;
- }
- if (!strcmp(name, "vkDestroyImage")) {
- return (void*)entry_vkDestroyImage;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout")) {
- return (void*)entry_vkGetImageSubresourceLayout;
- }
- if (!strcmp(name, "vkCreateImageView")) {
- return (void*)entry_vkCreateImageView;
- }
- if (!strcmp(name, "vkDestroyImageView")) {
- return (void*)entry_vkDestroyImageView;
- }
- if (!strcmp(name, "vkCreateShaderModule")) {
- return (void*)entry_vkCreateShaderModule;
- }
- if (!strcmp(name, "vkDestroyShaderModule")) {
- return (void*)entry_vkDestroyShaderModule;
- }
- if (!strcmp(name, "vkCreatePipelineCache")) {
- return (void*)entry_vkCreatePipelineCache;
- }
- if (!strcmp(name, "vkDestroyPipelineCache")) {
- return (void*)entry_vkDestroyPipelineCache;
- }
- if (!strcmp(name, "vkGetPipelineCacheData")) {
- return (void*)entry_vkGetPipelineCacheData;
- }
- if (!strcmp(name, "vkMergePipelineCaches")) {
- return (void*)entry_vkMergePipelineCaches;
- }
- if (!strcmp(name, "vkCreateGraphicsPipelines")) {
- return (void*)entry_vkCreateGraphicsPipelines;
- }
- if (!strcmp(name, "vkCreateComputePipelines")) {
- return (void*)entry_vkCreateComputePipelines;
- }
- if (!strcmp(name, "vkDestroyPipeline")) {
- return (void*)entry_vkDestroyPipeline;
- }
- if (!strcmp(name, "vkCreatePipelineLayout")) {
- return (void*)entry_vkCreatePipelineLayout;
- }
- if (!strcmp(name, "vkDestroyPipelineLayout")) {
- return (void*)entry_vkDestroyPipelineLayout;
- }
- if (!strcmp(name, "vkCreateSampler")) {
- return (void*)entry_vkCreateSampler;
- }
- if (!strcmp(name, "vkDestroySampler")) {
- return (void*)entry_vkDestroySampler;
- }
- if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
- return (void*)entry_vkCreateDescriptorSetLayout;
- }
- if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
- return (void*)entry_vkDestroyDescriptorSetLayout;
- }
- if (!strcmp(name, "vkCreateDescriptorPool")) {
- return (void*)entry_vkCreateDescriptorPool;
- }
- if (!strcmp(name, "vkDestroyDescriptorPool")) {
- return (void*)entry_vkDestroyDescriptorPool;
- }
- if (!strcmp(name, "vkResetDescriptorPool")) {
- return (void*)entry_vkResetDescriptorPool;
- }
- if (!strcmp(name, "vkAllocateDescriptorSets")) {
- return (void*)entry_vkAllocateDescriptorSets;
- }
- if (!strcmp(name, "vkFreeDescriptorSets")) {
- return (void*)entry_vkFreeDescriptorSets;
- }
- if (!strcmp(name, "vkUpdateDescriptorSets")) {
- return (void*)entry_vkUpdateDescriptorSets;
- }
- if (!strcmp(name, "vkCreateFramebuffer")) {
- return (void*)entry_vkCreateFramebuffer;
- }
- if (!strcmp(name, "vkDestroyFramebuffer")) {
- return (void*)entry_vkDestroyFramebuffer;
- }
- if (!strcmp(name, "vkCreateRenderPass")) {
- return (void*)entry_vkCreateRenderPass;
- }
- if (!strcmp(name, "vkDestroyRenderPass")) {
- return (void*)entry_vkDestroyRenderPass;
- }
- if (!strcmp(name, "vkGetRenderAreaGranularity")) {
- return (void*)entry_vkGetRenderAreaGranularity;
- }
- if (!strcmp(name, "vkCreateCommandPool")) {
- return (void*)entry_vkCreateCommandPool;
- }
- if (!strcmp(name, "vkDestroyCommandPool")) {
- return (void*)entry_vkDestroyCommandPool;
- }
- if (!strcmp(name, "vkResetCommandPool")) {
- return (void*)entry_vkResetCommandPool;
- }
- if (!strcmp(name, "vkAllocateCommandBuffers")) {
- return (void*)entry_vkAllocateCommandBuffers;
- }
- if (!strcmp(name, "vkFreeCommandBuffers")) {
- return (void*)entry_vkFreeCommandBuffers;
- }
- if (!strcmp(name, "vkBeginCommandBuffer")) {
- return (void*)entry_vkBeginCommandBuffer;
- }
- if (!strcmp(name, "vkEndCommandBuffer")) {
- return (void*)entry_vkEndCommandBuffer;
- }
- if (!strcmp(name, "vkResetCommandBuffer")) {
- return (void*)entry_vkResetCommandBuffer;
- }
- if (!strcmp(name, "vkCmdBindPipeline")) {
- return (void*)entry_vkCmdBindPipeline;
- }
- if (!strcmp(name, "vkCmdSetViewport")) {
- return (void*)entry_vkCmdSetViewport;
- }
- if (!strcmp(name, "vkCmdSetScissor")) {
- return (void*)entry_vkCmdSetScissor;
- }
- if (!strcmp(name, "vkCmdSetLineWidth")) {
- return (void*)entry_vkCmdSetLineWidth;
- }
- if (!strcmp(name, "vkCmdSetDepthBias")) {
- return (void*)entry_vkCmdSetDepthBias;
- }
- if (!strcmp(name, "vkCmdSetBlendConstants")) {
- return (void*)entry_vkCmdSetBlendConstants;
- }
- if (!strcmp(name, "vkCmdSetDepthBounds")) {
- return (void*)entry_vkCmdSetDepthBounds;
- }
- if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
- return (void*)entry_vkCmdSetStencilCompareMask;
- }
- if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
- return (void*)entry_vkCmdSetStencilWriteMask;
- }
- if (!strcmp(name, "vkCmdSetStencilReference")) {
- return (void*)entry_vkCmdSetStencilReference;
- }
- if (!strcmp(name, "vkCmdBindDescriptorSets")) {
- return (void*)entry_vkCmdBindDescriptorSets;
- }
- if (!strcmp(name, "vkCmdBindIndexBuffer")) {
- return (void*)entry_vkCmdBindIndexBuffer;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers")) {
- return (void*)entry_vkCmdBindVertexBuffers;
- }
- if (!strcmp(name, "vkCmdDraw")) {
- return (void*)entry_vkCmdDraw;
- }
- if (!strcmp(name, "vkCmdDrawIndexed")) {
- return (void*)entry_vkCmdDrawIndexed;
- }
- if (!strcmp(name, "vkCmdDrawIndirect")) {
- return (void*)entry_vkCmdDrawIndirect;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
- return (void*)entry_vkCmdDrawIndexedIndirect;
- }
- if (!strcmp(name, "vkCmdDispatch")) {
- return (void*)entry_vkCmdDispatch;
- }
- if (!strcmp(name, "vkCmdDispatchIndirect")) {
- return (void*)entry_vkCmdDispatchIndirect;
- }
- if (!strcmp(name, "vkCmdCopyBuffer")) {
- return (void*)entry_vkCmdCopyBuffer;
- }
- if (!strcmp(name, "vkCmdCopyImage")) {
- return (void*)entry_vkCmdCopyImage;
- }
- if (!strcmp(name, "vkCmdBlitImage")) {
- return (void*)entry_vkCmdBlitImage;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage")) {
- return (void*)entry_vkCmdCopyBufferToImage;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
- return (void*)entry_vkCmdCopyImageToBuffer;
- }
- if (!strcmp(name, "vkCmdUpdateBuffer")) {
- return (void*)entry_vkCmdUpdateBuffer;
- }
- if (!strcmp(name, "vkCmdFillBuffer")) {
- return (void*)entry_vkCmdFillBuffer;
- }
- if (!strcmp(name, "vkCmdClearColorImage")) {
- return (void*)entry_vkCmdClearColorImage;
- }
- if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
- return (void*)entry_vkCmdClearDepthStencilImage;
- }
- if (!strcmp(name, "vkCmdClearAttachments")) {
- return (void*)entry_vkCmdClearAttachments;
- }
- if (!strcmp(name, "vkCmdResolveImage")) {
- return (void*)entry_vkCmdResolveImage;
- }
- if (!strcmp(name, "vkCmdSetEvent")) {
- return (void*)entry_vkCmdSetEvent;
- }
- if (!strcmp(name, "vkCmdResetEvent")) {
- return (void*)entry_vkCmdResetEvent;
- }
- if (!strcmp(name, "vkCmdWaitEvents")) {
- return (void*)entry_vkCmdWaitEvents;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier")) {
- return (void*)entry_vkCmdPipelineBarrier;
- }
- if (!strcmp(name, "vkCmdBeginQuery")) {
- return (void*)entry_vkCmdBeginQuery;
- }
- if (!strcmp(name, "vkCmdEndQuery")) {
- return (void*)entry_vkCmdEndQuery;
- }
- if (!strcmp(name, "vkCmdResetQueryPool")) {
- return (void*)entry_vkCmdResetQueryPool;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp")) {
- return (void*)entry_vkCmdWriteTimestamp;
- }
- if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
- return (void*)entry_vkCmdCopyQueryPoolResults;
- }
- if (!strcmp(name, "vkCmdPushConstants")) {
- return (void*)entry_vkCmdPushConstants;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass")) {
- return (void*)entry_vkCmdBeginRenderPass;
- }
- if (!strcmp(name, "vkCmdNextSubpass")) {
- return (void*)entry_vkCmdNextSubpass;
- }
- if (!strcmp(name, "vkCmdEndRenderPass")) {
- return (void*)entry_vkCmdEndRenderPass;
- }
- if (!strcmp(name, "vkCmdExecuteCommands")) {
- return (void*)entry_vkCmdExecuteCommands;
- }
-#endif
-#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBindBufferMemory2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDeviceMask")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdDispatchBase")) {
- return nullptr;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkTrimCommandPool")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceQueue2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
- return nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateRenderPass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkResetQueryPool")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
- return nullptr;
- }
- if (!strcmp(name, "vkWaitSemaphores")) {
- return nullptr;
- }
- if (!strcmp(name, "vkSignalSemaphore")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferDeviceAddress")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
- return nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_3
- if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreatePrivateDataSlot")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
- return nullptr;
- }
- if (!strcmp(name, "vkSetPrivateData")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPrivateData")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetEvent2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBuffer2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRendering")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRendering")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetCullMode")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFace")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOp")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderingKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetFenceFdKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkAcquireImageANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_host_image_copy
- if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCopyImageToImageEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkSetPrivateDataEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPrivateDataEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBlobGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
- return nullptr;
- }
-#endif
- return nullptr;
-}
-void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name) {
- auto resources = ResourceTracker::get();
- bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1;
- bool has1_2OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_2;
- bool has1_3OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_3;
-#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance")) {
- return (void*)entry_vkCreateInstance;
- }
- if (!strcmp(name, "vkDestroyInstance")) {
- return (void*)entry_vkDestroyInstance;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
- return (void*)entry_vkEnumeratePhysicalDevices;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
- return (void*)entry_vkGetPhysicalDeviceFeatures;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
- return (void*)entry_vkGetPhysicalDeviceProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
- return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
- return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
- }
- if (!strcmp(name, "vkGetInstanceProcAddr")) {
- return (void*)entry_vkGetInstanceProcAddr;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (void*)entry_vkGetDeviceProcAddr;
- }
- if (!strcmp(name, "vkCreateDevice")) {
- return (void*)entry_vkCreateDevice;
- }
- if (!strcmp(name, "vkDestroyDevice")) {
- return (void*)entry_vkDestroyDevice;
- }
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (void*)entry_vkEnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
- return (void*)entry_vkEnumerateDeviceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
- return (void*)entry_vkEnumerateInstanceLayerProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
- return (void*)entry_vkEnumerateDeviceLayerProperties;
- }
- if (!strcmp(name, "vkGetDeviceQueue")) {
- return (void*)entry_vkGetDeviceQueue;
- }
- if (!strcmp(name, "vkQueueSubmit")) {
- return (void*)entry_vkQueueSubmit;
- }
- if (!strcmp(name, "vkQueueWaitIdle")) {
- return (void*)entry_vkQueueWaitIdle;
- }
- if (!strcmp(name, "vkDeviceWaitIdle")) {
- return (void*)entry_vkDeviceWaitIdle;
- }
- if (!strcmp(name, "vkAllocateMemory")) {
- return (void*)entry_vkAllocateMemory;
- }
- if (!strcmp(name, "vkFreeMemory")) {
- return (void*)entry_vkFreeMemory;
- }
- if (!strcmp(name, "vkMapMemory")) {
- return (void*)entry_vkMapMemory;
- }
- if (!strcmp(name, "vkUnmapMemory")) {
- return (void*)entry_vkUnmapMemory;
- }
- if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
- return (void*)entry_vkFlushMappedMemoryRanges;
- }
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
- return (void*)entry_vkInvalidateMappedMemoryRanges;
- }
- if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
- return (void*)entry_vkGetDeviceMemoryCommitment;
- }
- if (!strcmp(name, "vkBindBufferMemory")) {
- return (void*)entry_vkBindBufferMemory;
- }
- if (!strcmp(name, "vkBindImageMemory")) {
- return (void*)entry_vkBindImageMemory;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
- return (void*)entry_vkGetBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements")) {
- return (void*)entry_vkGetImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
- return (void*)entry_vkGetImageSparseMemoryRequirements;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
- }
- if (!strcmp(name, "vkQueueBindSparse")) {
- return (void*)entry_vkQueueBindSparse;
- }
- if (!strcmp(name, "vkCreateFence")) {
- return (void*)entry_vkCreateFence;
- }
- if (!strcmp(name, "vkDestroyFence")) {
- return (void*)entry_vkDestroyFence;
- }
- if (!strcmp(name, "vkResetFences")) {
- return (void*)entry_vkResetFences;
- }
- if (!strcmp(name, "vkGetFenceStatus")) {
- return (void*)entry_vkGetFenceStatus;
- }
- if (!strcmp(name, "vkWaitForFences")) {
- return (void*)entry_vkWaitForFences;
- }
- if (!strcmp(name, "vkCreateSemaphore")) {
- return (void*)entry_vkCreateSemaphore;
- }
- if (!strcmp(name, "vkDestroySemaphore")) {
- return (void*)entry_vkDestroySemaphore;
- }
- if (!strcmp(name, "vkCreateEvent")) {
- return (void*)entry_vkCreateEvent;
- }
- if (!strcmp(name, "vkDestroyEvent")) {
- return (void*)entry_vkDestroyEvent;
- }
- if (!strcmp(name, "vkGetEventStatus")) {
- return (void*)entry_vkGetEventStatus;
- }
- if (!strcmp(name, "vkSetEvent")) {
- return (void*)entry_vkSetEvent;
- }
- if (!strcmp(name, "vkResetEvent")) {
- return (void*)entry_vkResetEvent;
- }
- if (!strcmp(name, "vkCreateQueryPool")) {
- return (void*)entry_vkCreateQueryPool;
- }
- if (!strcmp(name, "vkDestroyQueryPool")) {
- return (void*)entry_vkDestroyQueryPool;
- }
- if (!strcmp(name, "vkGetQueryPoolResults")) {
- return (void*)entry_vkGetQueryPoolResults;
- }
- if (!strcmp(name, "vkCreateBuffer")) {
- return (void*)entry_vkCreateBuffer;
- }
- if (!strcmp(name, "vkDestroyBuffer")) {
- return (void*)entry_vkDestroyBuffer;
- }
- if (!strcmp(name, "vkCreateBufferView")) {
- return (void*)entry_vkCreateBufferView;
- }
- if (!strcmp(name, "vkDestroyBufferView")) {
- return (void*)entry_vkDestroyBufferView;
- }
- if (!strcmp(name, "vkCreateImage")) {
- return (void*)entry_vkCreateImage;
- }
- if (!strcmp(name, "vkDestroyImage")) {
- return (void*)entry_vkDestroyImage;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout")) {
- return (void*)entry_vkGetImageSubresourceLayout;
- }
- if (!strcmp(name, "vkCreateImageView")) {
- return (void*)entry_vkCreateImageView;
- }
- if (!strcmp(name, "vkDestroyImageView")) {
- return (void*)entry_vkDestroyImageView;
- }
- if (!strcmp(name, "vkCreateShaderModule")) {
- return (void*)entry_vkCreateShaderModule;
- }
- if (!strcmp(name, "vkDestroyShaderModule")) {
- return (void*)entry_vkDestroyShaderModule;
- }
- if (!strcmp(name, "vkCreatePipelineCache")) {
- return (void*)entry_vkCreatePipelineCache;
- }
- if (!strcmp(name, "vkDestroyPipelineCache")) {
- return (void*)entry_vkDestroyPipelineCache;
- }
- if (!strcmp(name, "vkGetPipelineCacheData")) {
- return (void*)entry_vkGetPipelineCacheData;
- }
- if (!strcmp(name, "vkMergePipelineCaches")) {
- return (void*)entry_vkMergePipelineCaches;
- }
- if (!strcmp(name, "vkCreateGraphicsPipelines")) {
- return (void*)entry_vkCreateGraphicsPipelines;
- }
- if (!strcmp(name, "vkCreateComputePipelines")) {
- return (void*)entry_vkCreateComputePipelines;
- }
- if (!strcmp(name, "vkDestroyPipeline")) {
- return (void*)entry_vkDestroyPipeline;
- }
- if (!strcmp(name, "vkCreatePipelineLayout")) {
- return (void*)entry_vkCreatePipelineLayout;
- }
- if (!strcmp(name, "vkDestroyPipelineLayout")) {
- return (void*)entry_vkDestroyPipelineLayout;
- }
- if (!strcmp(name, "vkCreateSampler")) {
- return (void*)entry_vkCreateSampler;
- }
- if (!strcmp(name, "vkDestroySampler")) {
- return (void*)entry_vkDestroySampler;
- }
- if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
- return (void*)entry_vkCreateDescriptorSetLayout;
- }
- if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
- return (void*)entry_vkDestroyDescriptorSetLayout;
- }
- if (!strcmp(name, "vkCreateDescriptorPool")) {
- return (void*)entry_vkCreateDescriptorPool;
- }
- if (!strcmp(name, "vkDestroyDescriptorPool")) {
- return (void*)entry_vkDestroyDescriptorPool;
- }
- if (!strcmp(name, "vkResetDescriptorPool")) {
- return (void*)entry_vkResetDescriptorPool;
- }
- if (!strcmp(name, "vkAllocateDescriptorSets")) {
- return (void*)entry_vkAllocateDescriptorSets;
- }
- if (!strcmp(name, "vkFreeDescriptorSets")) {
- return (void*)entry_vkFreeDescriptorSets;
- }
- if (!strcmp(name, "vkUpdateDescriptorSets")) {
- return (void*)entry_vkUpdateDescriptorSets;
- }
- if (!strcmp(name, "vkCreateFramebuffer")) {
- return (void*)entry_vkCreateFramebuffer;
- }
- if (!strcmp(name, "vkDestroyFramebuffer")) {
- return (void*)entry_vkDestroyFramebuffer;
- }
- if (!strcmp(name, "vkCreateRenderPass")) {
- return (void*)entry_vkCreateRenderPass;
- }
- if (!strcmp(name, "vkDestroyRenderPass")) {
- return (void*)entry_vkDestroyRenderPass;
- }
- if (!strcmp(name, "vkGetRenderAreaGranularity")) {
- return (void*)entry_vkGetRenderAreaGranularity;
- }
- if (!strcmp(name, "vkCreateCommandPool")) {
- return (void*)entry_vkCreateCommandPool;
- }
- if (!strcmp(name, "vkDestroyCommandPool")) {
- return (void*)entry_vkDestroyCommandPool;
- }
- if (!strcmp(name, "vkResetCommandPool")) {
- return (void*)entry_vkResetCommandPool;
- }
- if (!strcmp(name, "vkAllocateCommandBuffers")) {
- return (void*)entry_vkAllocateCommandBuffers;
- }
- if (!strcmp(name, "vkFreeCommandBuffers")) {
- return (void*)entry_vkFreeCommandBuffers;
- }
- if (!strcmp(name, "vkBeginCommandBuffer")) {
- return (void*)entry_vkBeginCommandBuffer;
- }
- if (!strcmp(name, "vkEndCommandBuffer")) {
- return (void*)entry_vkEndCommandBuffer;
- }
- if (!strcmp(name, "vkResetCommandBuffer")) {
- return (void*)entry_vkResetCommandBuffer;
- }
- if (!strcmp(name, "vkCmdBindPipeline")) {
- return (void*)entry_vkCmdBindPipeline;
- }
- if (!strcmp(name, "vkCmdSetViewport")) {
- return (void*)entry_vkCmdSetViewport;
- }
- if (!strcmp(name, "vkCmdSetScissor")) {
- return (void*)entry_vkCmdSetScissor;
- }
- if (!strcmp(name, "vkCmdSetLineWidth")) {
- return (void*)entry_vkCmdSetLineWidth;
- }
- if (!strcmp(name, "vkCmdSetDepthBias")) {
- return (void*)entry_vkCmdSetDepthBias;
- }
- if (!strcmp(name, "vkCmdSetBlendConstants")) {
- return (void*)entry_vkCmdSetBlendConstants;
- }
- if (!strcmp(name, "vkCmdSetDepthBounds")) {
- return (void*)entry_vkCmdSetDepthBounds;
- }
- if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
- return (void*)entry_vkCmdSetStencilCompareMask;
- }
- if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
- return (void*)entry_vkCmdSetStencilWriteMask;
- }
- if (!strcmp(name, "vkCmdSetStencilReference")) {
- return (void*)entry_vkCmdSetStencilReference;
- }
- if (!strcmp(name, "vkCmdBindDescriptorSets")) {
- return (void*)entry_vkCmdBindDescriptorSets;
- }
- if (!strcmp(name, "vkCmdBindIndexBuffer")) {
- return (void*)entry_vkCmdBindIndexBuffer;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers")) {
- return (void*)entry_vkCmdBindVertexBuffers;
- }
- if (!strcmp(name, "vkCmdDraw")) {
- return (void*)entry_vkCmdDraw;
- }
- if (!strcmp(name, "vkCmdDrawIndexed")) {
- return (void*)entry_vkCmdDrawIndexed;
- }
- if (!strcmp(name, "vkCmdDrawIndirect")) {
- return (void*)entry_vkCmdDrawIndirect;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
- return (void*)entry_vkCmdDrawIndexedIndirect;
- }
- if (!strcmp(name, "vkCmdDispatch")) {
- return (void*)entry_vkCmdDispatch;
- }
- if (!strcmp(name, "vkCmdDispatchIndirect")) {
- return (void*)entry_vkCmdDispatchIndirect;
- }
- if (!strcmp(name, "vkCmdCopyBuffer")) {
- return (void*)entry_vkCmdCopyBuffer;
- }
- if (!strcmp(name, "vkCmdCopyImage")) {
- return (void*)entry_vkCmdCopyImage;
- }
- if (!strcmp(name, "vkCmdBlitImage")) {
- return (void*)entry_vkCmdBlitImage;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage")) {
- return (void*)entry_vkCmdCopyBufferToImage;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
- return (void*)entry_vkCmdCopyImageToBuffer;
- }
- if (!strcmp(name, "vkCmdUpdateBuffer")) {
- return (void*)entry_vkCmdUpdateBuffer;
- }
- if (!strcmp(name, "vkCmdFillBuffer")) {
- return (void*)entry_vkCmdFillBuffer;
- }
- if (!strcmp(name, "vkCmdClearColorImage")) {
- return (void*)entry_vkCmdClearColorImage;
- }
- if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
- return (void*)entry_vkCmdClearDepthStencilImage;
- }
- if (!strcmp(name, "vkCmdClearAttachments")) {
- return (void*)entry_vkCmdClearAttachments;
- }
- if (!strcmp(name, "vkCmdResolveImage")) {
- return (void*)entry_vkCmdResolveImage;
- }
- if (!strcmp(name, "vkCmdSetEvent")) {
- return (void*)entry_vkCmdSetEvent;
- }
- if (!strcmp(name, "vkCmdResetEvent")) {
- return (void*)entry_vkCmdResetEvent;
- }
- if (!strcmp(name, "vkCmdWaitEvents")) {
- return (void*)entry_vkCmdWaitEvents;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier")) {
- return (void*)entry_vkCmdPipelineBarrier;
- }
- if (!strcmp(name, "vkCmdBeginQuery")) {
- return (void*)entry_vkCmdBeginQuery;
- }
- if (!strcmp(name, "vkCmdEndQuery")) {
- return (void*)entry_vkCmdEndQuery;
- }
- if (!strcmp(name, "vkCmdResetQueryPool")) {
- return (void*)entry_vkCmdResetQueryPool;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp")) {
- return (void*)entry_vkCmdWriteTimestamp;
- }
- if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
- return (void*)entry_vkCmdCopyQueryPoolResults;
- }
- if (!strcmp(name, "vkCmdPushConstants")) {
- return (void*)entry_vkCmdPushConstants;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass")) {
- return (void*)entry_vkCmdBeginRenderPass;
- }
- if (!strcmp(name, "vkCmdNextSubpass")) {
- return (void*)entry_vkCmdNextSubpass;
- }
- if (!strcmp(name, "vkCmdEndRenderPass")) {
- return (void*)entry_vkCmdEndRenderPass;
- }
- if (!strcmp(name, "vkCmdExecuteCommands")) {
- return (void*)entry_vkCmdExecuteCommands;
- }
-#endif
-#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion")) {
- return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
- }
- if (!strcmp(name, "vkBindBufferMemory2")) {
- return (void*)dynCheck_entry_vkBindBufferMemory2;
- }
- if (!strcmp(name, "vkBindImageMemory2")) {
- return (void*)dynCheck_entry_vkBindImageMemory2;
- }
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
- return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures;
- }
- if (!strcmp(name, "vkCmdSetDeviceMask")) {
- return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
- }
- if (!strcmp(name, "vkCmdDispatchBase")) {
- return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
- return (void*)dynCheck_entry_vkGetImageMemoryRequirements2;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
- return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
- return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
- : nullptr;
- }
- if (!strcmp(name, "vkTrimCommandPool")) {
- return (void*)dynCheck_entry_vkTrimCommandPool;
- }
- if (!strcmp(name, "vkGetDeviceQueue2")) {
- return (void*)dynCheck_entry_vkGetDeviceQueue2;
- }
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
- return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversion;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
- return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversion;
- }
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
- return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplate;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
- return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplate;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
- return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplate;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
- : nullptr;
- }
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
- return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupport;
- }
-#endif
-#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCreateRenderPass2")) {
- return (void*)dynCheck_entry_vkCreateRenderPass2;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkResetQueryPool")) {
- return (void*)dynCheck_entry_vkResetQueryPool;
- }
- if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
- return (void*)dynCheck_entry_vkGetSemaphoreCounterValue;
- }
- if (!strcmp(name, "vkWaitSemaphores")) {
- return (void*)dynCheck_entry_vkWaitSemaphores;
- }
- if (!strcmp(name, "vkSignalSemaphore")) {
- return (void*)dynCheck_entry_vkSignalSemaphore;
- }
- if (!strcmp(name, "vkGetBufferDeviceAddress")) {
- return (void*)dynCheck_entry_vkGetBufferDeviceAddress;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
- return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddress;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
- return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress;
- }
-#endif
-#ifdef VK_VERSION_1_3
- if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
- return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
- }
- if (!strcmp(name, "vkCreatePrivateDataSlot")) {
- return (void*)dynCheck_entry_vkCreatePrivateDataSlot;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
- return (void*)dynCheck_entry_vkDestroyPrivateDataSlot;
- }
- if (!strcmp(name, "vkSetPrivateData")) {
- return (void*)dynCheck_entry_vkSetPrivateData;
- }
- if (!strcmp(name, "vkGetPrivateData")) {
- return (void*)dynCheck_entry_vkGetPrivateData;
- }
- if (!strcmp(name, "vkCmdSetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2")) {
- return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdSetCullMode")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFace")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
- return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
- return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
- return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements;
- }
-#endif
-#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_android_surface");
- return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginRenderingKHR;
- }
- if (!strcmp(name, "vkCmdEndRenderingKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndRenderingKHR;
- }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkTrimCommandPoolKHR;
- }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_external_memory_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkImportSemaphoreFdKHR;
- }
- if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetSemaphoreFdKHR;
- }
-#endif
-#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR;
- }
-#endif
-#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreateRenderPass2KHR;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginRenderPass2KHR;
- }
- if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdNextSubpass2KHR;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndRenderPass2KHR;
- }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_external_fence_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkImportFenceFdKHR;
- }
- if (!strcmp(name, "vkGetFenceFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetFenceFdKHR;
- }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageMemoryRequirements2KHR;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2KHR;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR;
- }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversionKHR;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversionKHR;
- }
-#endif
-#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkBindBufferMemory2KHR;
- }
- if (!strcmp(name, "vkBindImageMemory2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkBindImageMemory2KHR;
- }
-#endif
-#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR;
- }
-#endif
-#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetBufferDeviceAddressKHR;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
- }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPipelineExecutablePropertiesKHR;
- }
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPipelineExecutableStatisticsKHR;
- }
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR;
- }
-#endif
-#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetEvent2KHR;
- }
- if (!strcmp(name, "vkCmdResetEvent2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdResetEvent2KHR;
- }
- if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdWaitEvents2KHR;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdPipelineBarrier2KHR;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdWriteTimestamp2KHR;
- }
- if (!strcmp(name, "vkQueueSubmit2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkQueueSubmit2KHR;
- }
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdWriteBufferMarker2AMD;
- }
- if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkGetQueueCheckpointData2NV;
- }
-#endif
-#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyBuffer2KHR;
- }
- if (!strcmp(name, "vkCmdCopyImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyImage2KHR;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyBufferToImage2KHR;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyImageToBuffer2KHR;
- }
- if (!strcmp(name, "vkCmdBlitImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBlitImage2KHR;
- }
- if (!strcmp(name, "vkCmdResolveImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdResolveImage2KHR;
- }
-#endif
-#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBindIndexBuffer2KHR;
- }
- if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetRenderingAreaGranularityKHR;
- }
- if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageSubresourceLayout2KHR;
- }
-#endif
-#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetSwapchainGrallocUsageANDROID;
- }
- if (!strcmp(name, "vkAcquireImageANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkAcquireImageANDROID;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkQueueSignalReleaseImageANDROID;
- }
- if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID;
- }
-#endif
-#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT;
- }
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginTransformFeedbackEXT;
- }
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndTransformFeedbackEXT;
- }
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginQueryIndexedEXT;
- }
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndQueryIndexedEXT;
- }
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdDrawIndirectByteCountEXT;
- }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID;
- }
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID;
- }
-#endif
-#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT;
- }
-#endif
-#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetLineStippleEXT;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetCullModeEXT;
- }
- if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetFrontFaceEXT;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetPrimitiveTopologyEXT;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetViewportWithCountEXT;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetScissorWithCountEXT;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBindVertexBuffers2EXT;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthTestEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthWriteEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthCompareOpEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetStencilTestEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetStencilOpEXT;
- }
-#endif
-#ifdef VK_EXT_host_image_copy
- if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCopyMemoryToImageEXT;
- }
- if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCopyImageToMemoryEXT;
- }
- if (!strcmp(name, "vkCopyImageToImageEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCopyImageToImageEXT;
- }
- if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkTransitionImageLayoutEXT;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageSubresourceLayout2EXT;
- }
-#endif
-#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreatePrivateDataSlotEXT;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkDestroyPrivateDataSlotEXT;
- }
- if (!strcmp(name, "vkSetPrivateDataEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkSetPrivateDataEXT;
- }
- if (!strcmp(name, "vkGetPrivateDataEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPrivateDataEXT;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetPatchControlPointsEXT;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthBiasEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetLogicOpEXT;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT;
- }
-#endif
-#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE
- : nullptr;
- }
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkFreeMemorySyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayoutGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayout2GOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetBlobGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetBlobGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE
- : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
- }
-#endif
- return nullptr;
-}
-void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name) {
- auto resources = ResourceTracker::get();
- bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1;
- bool has1_2OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_2;
- bool has1_3OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_3;
-#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance")) {
- return (void*)entry_vkCreateInstance;
- }
- if (!strcmp(name, "vkDestroyInstance")) {
- return (void*)entry_vkDestroyInstance;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
- return (void*)entry_vkEnumeratePhysicalDevices;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
- return (void*)entry_vkGetPhysicalDeviceFeatures;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
- return (void*)entry_vkGetPhysicalDeviceProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
- return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
- return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
- }
- if (!strcmp(name, "vkGetInstanceProcAddr")) {
- return (void*)entry_vkGetInstanceProcAddr;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (void*)entry_vkGetDeviceProcAddr;
- }
- if (!strcmp(name, "vkCreateDevice")) {
- return (void*)entry_vkCreateDevice;
- }
- if (!strcmp(name, "vkDestroyDevice")) {
- return (void*)entry_vkDestroyDevice;
- }
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (void*)entry_vkEnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
- return (void*)entry_vkEnumerateDeviceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
- return (void*)entry_vkEnumerateInstanceLayerProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
- return (void*)entry_vkEnumerateDeviceLayerProperties;
- }
- if (!strcmp(name, "vkGetDeviceQueue")) {
- return (void*)entry_vkGetDeviceQueue;
- }
- if (!strcmp(name, "vkQueueSubmit")) {
- return (void*)entry_vkQueueSubmit;
- }
- if (!strcmp(name, "vkQueueWaitIdle")) {
- return (void*)entry_vkQueueWaitIdle;
- }
- if (!strcmp(name, "vkDeviceWaitIdle")) {
- return (void*)entry_vkDeviceWaitIdle;
- }
- if (!strcmp(name, "vkAllocateMemory")) {
- return (void*)entry_vkAllocateMemory;
- }
- if (!strcmp(name, "vkFreeMemory")) {
- return (void*)entry_vkFreeMemory;
- }
- if (!strcmp(name, "vkMapMemory")) {
- return (void*)entry_vkMapMemory;
- }
- if (!strcmp(name, "vkUnmapMemory")) {
- return (void*)entry_vkUnmapMemory;
- }
- if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
- return (void*)entry_vkFlushMappedMemoryRanges;
- }
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
- return (void*)entry_vkInvalidateMappedMemoryRanges;
- }
- if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
- return (void*)entry_vkGetDeviceMemoryCommitment;
- }
- if (!strcmp(name, "vkBindBufferMemory")) {
- return (void*)entry_vkBindBufferMemory;
- }
- if (!strcmp(name, "vkBindImageMemory")) {
- return (void*)entry_vkBindImageMemory;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
- return (void*)entry_vkGetBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements")) {
- return (void*)entry_vkGetImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
- return (void*)entry_vkGetImageSparseMemoryRequirements;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
- }
- if (!strcmp(name, "vkQueueBindSparse")) {
- return (void*)entry_vkQueueBindSparse;
- }
- if (!strcmp(name, "vkCreateFence")) {
- return (void*)entry_vkCreateFence;
- }
- if (!strcmp(name, "vkDestroyFence")) {
- return (void*)entry_vkDestroyFence;
- }
- if (!strcmp(name, "vkResetFences")) {
- return (void*)entry_vkResetFences;
- }
- if (!strcmp(name, "vkGetFenceStatus")) {
- return (void*)entry_vkGetFenceStatus;
- }
- if (!strcmp(name, "vkWaitForFences")) {
- return (void*)entry_vkWaitForFences;
- }
- if (!strcmp(name, "vkCreateSemaphore")) {
- return (void*)entry_vkCreateSemaphore;
- }
- if (!strcmp(name, "vkDestroySemaphore")) {
- return (void*)entry_vkDestroySemaphore;
- }
- if (!strcmp(name, "vkCreateEvent")) {
- return (void*)entry_vkCreateEvent;
- }
- if (!strcmp(name, "vkDestroyEvent")) {
- return (void*)entry_vkDestroyEvent;
- }
- if (!strcmp(name, "vkGetEventStatus")) {
- return (void*)entry_vkGetEventStatus;
- }
- if (!strcmp(name, "vkSetEvent")) {
- return (void*)entry_vkSetEvent;
- }
- if (!strcmp(name, "vkResetEvent")) {
- return (void*)entry_vkResetEvent;
- }
- if (!strcmp(name, "vkCreateQueryPool")) {
- return (void*)entry_vkCreateQueryPool;
- }
- if (!strcmp(name, "vkDestroyQueryPool")) {
- return (void*)entry_vkDestroyQueryPool;
- }
- if (!strcmp(name, "vkGetQueryPoolResults")) {
- return (void*)entry_vkGetQueryPoolResults;
- }
- if (!strcmp(name, "vkCreateBuffer")) {
- return (void*)entry_vkCreateBuffer;
- }
- if (!strcmp(name, "vkDestroyBuffer")) {
- return (void*)entry_vkDestroyBuffer;
- }
- if (!strcmp(name, "vkCreateBufferView")) {
- return (void*)entry_vkCreateBufferView;
- }
- if (!strcmp(name, "vkDestroyBufferView")) {
- return (void*)entry_vkDestroyBufferView;
- }
- if (!strcmp(name, "vkCreateImage")) {
- return (void*)entry_vkCreateImage;
- }
- if (!strcmp(name, "vkDestroyImage")) {
- return (void*)entry_vkDestroyImage;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout")) {
- return (void*)entry_vkGetImageSubresourceLayout;
- }
- if (!strcmp(name, "vkCreateImageView")) {
- return (void*)entry_vkCreateImageView;
- }
- if (!strcmp(name, "vkDestroyImageView")) {
- return (void*)entry_vkDestroyImageView;
- }
- if (!strcmp(name, "vkCreateShaderModule")) {
- return (void*)entry_vkCreateShaderModule;
- }
- if (!strcmp(name, "vkDestroyShaderModule")) {
- return (void*)entry_vkDestroyShaderModule;
- }
- if (!strcmp(name, "vkCreatePipelineCache")) {
- return (void*)entry_vkCreatePipelineCache;
- }
- if (!strcmp(name, "vkDestroyPipelineCache")) {
- return (void*)entry_vkDestroyPipelineCache;
- }
- if (!strcmp(name, "vkGetPipelineCacheData")) {
- return (void*)entry_vkGetPipelineCacheData;
- }
- if (!strcmp(name, "vkMergePipelineCaches")) {
- return (void*)entry_vkMergePipelineCaches;
- }
- if (!strcmp(name, "vkCreateGraphicsPipelines")) {
- return (void*)entry_vkCreateGraphicsPipelines;
- }
- if (!strcmp(name, "vkCreateComputePipelines")) {
- return (void*)entry_vkCreateComputePipelines;
- }
- if (!strcmp(name, "vkDestroyPipeline")) {
- return (void*)entry_vkDestroyPipeline;
- }
- if (!strcmp(name, "vkCreatePipelineLayout")) {
- return (void*)entry_vkCreatePipelineLayout;
- }
- if (!strcmp(name, "vkDestroyPipelineLayout")) {
- return (void*)entry_vkDestroyPipelineLayout;
- }
- if (!strcmp(name, "vkCreateSampler")) {
- return (void*)entry_vkCreateSampler;
- }
- if (!strcmp(name, "vkDestroySampler")) {
- return (void*)entry_vkDestroySampler;
- }
- if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
- return (void*)entry_vkCreateDescriptorSetLayout;
- }
- if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
- return (void*)entry_vkDestroyDescriptorSetLayout;
- }
- if (!strcmp(name, "vkCreateDescriptorPool")) {
- return (void*)entry_vkCreateDescriptorPool;
- }
- if (!strcmp(name, "vkDestroyDescriptorPool")) {
- return (void*)entry_vkDestroyDescriptorPool;
- }
- if (!strcmp(name, "vkResetDescriptorPool")) {
- return (void*)entry_vkResetDescriptorPool;
- }
- if (!strcmp(name, "vkAllocateDescriptorSets")) {
- return (void*)entry_vkAllocateDescriptorSets;
- }
- if (!strcmp(name, "vkFreeDescriptorSets")) {
- return (void*)entry_vkFreeDescriptorSets;
- }
- if (!strcmp(name, "vkUpdateDescriptorSets")) {
- return (void*)entry_vkUpdateDescriptorSets;
- }
- if (!strcmp(name, "vkCreateFramebuffer")) {
- return (void*)entry_vkCreateFramebuffer;
- }
- if (!strcmp(name, "vkDestroyFramebuffer")) {
- return (void*)entry_vkDestroyFramebuffer;
- }
- if (!strcmp(name, "vkCreateRenderPass")) {
- return (void*)entry_vkCreateRenderPass;
- }
- if (!strcmp(name, "vkDestroyRenderPass")) {
- return (void*)entry_vkDestroyRenderPass;
- }
- if (!strcmp(name, "vkGetRenderAreaGranularity")) {
- return (void*)entry_vkGetRenderAreaGranularity;
- }
- if (!strcmp(name, "vkCreateCommandPool")) {
- return (void*)entry_vkCreateCommandPool;
- }
- if (!strcmp(name, "vkDestroyCommandPool")) {
- return (void*)entry_vkDestroyCommandPool;
- }
- if (!strcmp(name, "vkResetCommandPool")) {
- return (void*)entry_vkResetCommandPool;
- }
- if (!strcmp(name, "vkAllocateCommandBuffers")) {
- return (void*)entry_vkAllocateCommandBuffers;
- }
- if (!strcmp(name, "vkFreeCommandBuffers")) {
- return (void*)entry_vkFreeCommandBuffers;
- }
- if (!strcmp(name, "vkBeginCommandBuffer")) {
- return (void*)entry_vkBeginCommandBuffer;
- }
- if (!strcmp(name, "vkEndCommandBuffer")) {
- return (void*)entry_vkEndCommandBuffer;
- }
- if (!strcmp(name, "vkResetCommandBuffer")) {
- return (void*)entry_vkResetCommandBuffer;
- }
- if (!strcmp(name, "vkCmdBindPipeline")) {
- return (void*)entry_vkCmdBindPipeline;
- }
- if (!strcmp(name, "vkCmdSetViewport")) {
- return (void*)entry_vkCmdSetViewport;
- }
- if (!strcmp(name, "vkCmdSetScissor")) {
- return (void*)entry_vkCmdSetScissor;
- }
- if (!strcmp(name, "vkCmdSetLineWidth")) {
- return (void*)entry_vkCmdSetLineWidth;
- }
- if (!strcmp(name, "vkCmdSetDepthBias")) {
- return (void*)entry_vkCmdSetDepthBias;
- }
- if (!strcmp(name, "vkCmdSetBlendConstants")) {
- return (void*)entry_vkCmdSetBlendConstants;
- }
- if (!strcmp(name, "vkCmdSetDepthBounds")) {
- return (void*)entry_vkCmdSetDepthBounds;
- }
- if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
- return (void*)entry_vkCmdSetStencilCompareMask;
- }
- if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
- return (void*)entry_vkCmdSetStencilWriteMask;
- }
- if (!strcmp(name, "vkCmdSetStencilReference")) {
- return (void*)entry_vkCmdSetStencilReference;
- }
- if (!strcmp(name, "vkCmdBindDescriptorSets")) {
- return (void*)entry_vkCmdBindDescriptorSets;
- }
- if (!strcmp(name, "vkCmdBindIndexBuffer")) {
- return (void*)entry_vkCmdBindIndexBuffer;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers")) {
- return (void*)entry_vkCmdBindVertexBuffers;
- }
- if (!strcmp(name, "vkCmdDraw")) {
- return (void*)entry_vkCmdDraw;
- }
- if (!strcmp(name, "vkCmdDrawIndexed")) {
- return (void*)entry_vkCmdDrawIndexed;
- }
- if (!strcmp(name, "vkCmdDrawIndirect")) {
- return (void*)entry_vkCmdDrawIndirect;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
- return (void*)entry_vkCmdDrawIndexedIndirect;
- }
- if (!strcmp(name, "vkCmdDispatch")) {
- return (void*)entry_vkCmdDispatch;
- }
- if (!strcmp(name, "vkCmdDispatchIndirect")) {
- return (void*)entry_vkCmdDispatchIndirect;
- }
- if (!strcmp(name, "vkCmdCopyBuffer")) {
- return (void*)entry_vkCmdCopyBuffer;
- }
- if (!strcmp(name, "vkCmdCopyImage")) {
- return (void*)entry_vkCmdCopyImage;
- }
- if (!strcmp(name, "vkCmdBlitImage")) {
- return (void*)entry_vkCmdBlitImage;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage")) {
- return (void*)entry_vkCmdCopyBufferToImage;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
- return (void*)entry_vkCmdCopyImageToBuffer;
- }
- if (!strcmp(name, "vkCmdUpdateBuffer")) {
- return (void*)entry_vkCmdUpdateBuffer;
- }
- if (!strcmp(name, "vkCmdFillBuffer")) {
- return (void*)entry_vkCmdFillBuffer;
- }
- if (!strcmp(name, "vkCmdClearColorImage")) {
- return (void*)entry_vkCmdClearColorImage;
- }
- if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
- return (void*)entry_vkCmdClearDepthStencilImage;
- }
- if (!strcmp(name, "vkCmdClearAttachments")) {
- return (void*)entry_vkCmdClearAttachments;
- }
- if (!strcmp(name, "vkCmdResolveImage")) {
- return (void*)entry_vkCmdResolveImage;
- }
- if (!strcmp(name, "vkCmdSetEvent")) {
- return (void*)entry_vkCmdSetEvent;
- }
- if (!strcmp(name, "vkCmdResetEvent")) {
- return (void*)entry_vkCmdResetEvent;
- }
- if (!strcmp(name, "vkCmdWaitEvents")) {
- return (void*)entry_vkCmdWaitEvents;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier")) {
- return (void*)entry_vkCmdPipelineBarrier;
- }
- if (!strcmp(name, "vkCmdBeginQuery")) {
- return (void*)entry_vkCmdBeginQuery;
- }
- if (!strcmp(name, "vkCmdEndQuery")) {
- return (void*)entry_vkCmdEndQuery;
- }
- if (!strcmp(name, "vkCmdResetQueryPool")) {
- return (void*)entry_vkCmdResetQueryPool;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp")) {
- return (void*)entry_vkCmdWriteTimestamp;
- }
- if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
- return (void*)entry_vkCmdCopyQueryPoolResults;
- }
- if (!strcmp(name, "vkCmdPushConstants")) {
- return (void*)entry_vkCmdPushConstants;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass")) {
- return (void*)entry_vkCmdBeginRenderPass;
- }
- if (!strcmp(name, "vkCmdNextSubpass")) {
- return (void*)entry_vkCmdNextSubpass;
- }
- if (!strcmp(name, "vkCmdEndRenderPass")) {
- return (void*)entry_vkCmdEndRenderPass;
- }
- if (!strcmp(name, "vkCmdExecuteCommands")) {
- return (void*)entry_vkCmdExecuteCommands;
- }
-#endif
-#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion")) {
- return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
- }
- if (!strcmp(name, "vkBindBufferMemory2")) {
- return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2")) {
- return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
- return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDeviceMask")) {
- return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
- }
- if (!strcmp(name, "vkCmdDispatchBase")) {
- return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
- return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
- return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
- return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
- : nullptr;
- }
- if (!strcmp(name, "vkTrimCommandPool")) {
- return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceQueue2")) {
- return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr;
- }
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
- return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
- return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr;
- }
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
- return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
- return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
- return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
- : nullptr;
- }
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
- return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCreateRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCreateRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkResetQueryPool")) {
- return has1_2OrHigher ? (void*)entry_vkResetQueryPool : nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
- return has1_2OrHigher ? (void*)entry_vkGetSemaphoreCounterValue : nullptr;
- }
- if (!strcmp(name, "vkWaitSemaphores")) {
- return has1_2OrHigher ? (void*)entry_vkWaitSemaphores : nullptr;
- }
- if (!strcmp(name, "vkSignalSemaphore")) {
- return has1_2OrHigher ? (void*)entry_vkSignalSemaphore : nullptr;
- }
- if (!strcmp(name, "vkGetBufferDeviceAddress")) {
- return has1_2OrHigher ? (void*)entry_vkGetBufferDeviceAddress : nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
- return has1_2OrHigher ? (void*)entry_vkGetBufferOpaqueCaptureAddress : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
- return has1_2OrHigher ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddress : nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_3
- if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
- return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
- }
- if (!strcmp(name, "vkCreatePrivateDataSlot")) {
- return has1_3OrHigher ? (void*)entry_vkCreatePrivateDataSlot : nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
- return has1_3OrHigher ? (void*)entry_vkDestroyPrivateDataSlot : nullptr;
- }
- if (!strcmp(name, "vkSetPrivateData")) {
- return has1_3OrHigher ? (void*)entry_vkSetPrivateData : nullptr;
- }
- if (!strcmp(name, "vkGetPrivateData")) {
- return has1_3OrHigher ? (void*)entry_vkGetPrivateData : nullptr;
- }
- if (!strcmp(name, "vkCmdSetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2")) {
- return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdSetCullMode")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFace")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
- return has1_3OrHigher ? (void*)entry_vkGetDeviceBufferMemoryRequirements : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
- return has1_3OrHigher ? (void*)entry_vkGetDeviceImageMemoryRequirements : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
- return has1_3OrHigher ? (void*)entry_vkGetDeviceImageSparseMemoryRequirements : nullptr;
- }
-#endif
-#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_android_surface");
- return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
- return hasExt ? (void*)entry_vkCmdBeginRenderingKHR : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderingKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
- return hasExt ? (void*)entry_vkCmdEndRenderingKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance1");
- return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
- return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
- return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
- return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
- return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
- return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCmdBeginRenderPass2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCmdNextSubpass2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCmdEndRenderPass2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
- return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr;
- }
- if (!strcmp(name, "vkGetFenceFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
- return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
- return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
- return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
- return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
- return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
- return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
- return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
- return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance3");
- return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
- return hasExt ? (void*)entry_vkGetBufferDeviceAddressKHR : nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
- return hasExt ? (void*)entry_vkGetBufferOpaqueCaptureAddressKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
- return hasExt ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
- return hasExt ? (void*)entry_vkGetPipelineExecutablePropertiesKHR : nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
- return hasExt ? (void*)entry_vkGetPipelineExecutableStatisticsKHR : nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
- return hasExt ? (void*)entry_vkGetPipelineExecutableInternalRepresentationsKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdSetEvent2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdResetEvent2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdWaitEvents2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdPipelineBarrier2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdWriteTimestamp2KHR : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkQueueSubmit2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdWriteBufferMarker2AMD : nullptr;
- }
- if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkGetQueueCheckpointData2NV : nullptr;
- }
-#endif
-#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyBuffer2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyImage2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyBufferToImage2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyImageToBuffer2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdBlitImage2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdResolveImage2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
- return hasExt ? (void*)entry_vkGetDeviceBufferMemoryRequirementsKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
- return hasExt ? (void*)entry_vkGetDeviceImageMemoryRequirementsKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
- return hasExt ? (void*)entry_vkGetDeviceImageSparseMemoryRequirementsKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkCmdBindIndexBuffer2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkGetRenderingAreaGranularityKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkGetDeviceImageSubresourceLayoutKHR : nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkGetImageSubresourceLayout2KHR : nullptr;
- }
-#endif
-#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr;
- }
- if (!strcmp(name, "vkAcquireImageANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr;
- }
- if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkGetSwapchainGrallocUsage2ANDROID : nullptr;
- }
-#endif
-#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdBindTransformFeedbackBuffersEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdBeginTransformFeedbackEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdEndTransformFeedbackEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdBeginQueryIndexedEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdEndQueryIndexedEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdDrawIndirectByteCountEXT : nullptr;
- }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
- bool hasExt = resources->hasDeviceExtension(
- device, "VK_ANDROID_external_memory_android_hardware_buffer");
- return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr;
- }
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
- bool hasExt = resources->hasDeviceExtension(
- device, "VK_ANDROID_external_memory_android_hardware_buffer");
- return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr;
- }
-#endif
-#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_tooling_info");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_line_rasterization");
- return hasExt ? (void*)entry_vkCmdSetLineStippleEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetCullModeEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetFrontFaceEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetPrimitiveTopologyEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetViewportWithCountEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetScissorWithCountEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdBindVertexBuffers2EXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthTestEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthWriteEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthCompareOpEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthBoundsTestEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetStencilTestEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetStencilOpEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_host_image_copy
- if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkCopyMemoryToImageEXT : nullptr;
- }
- if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkCopyImageToMemoryEXT : nullptr;
- }
- if (!strcmp(name, "vkCopyImageToImageEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkCopyImageToImageEXT : nullptr;
- }
- if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkTransitionImageLayoutEXT : nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkGetImageSubresourceLayout2EXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkCreatePrivateDataSlotEXT : nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkDestroyPrivateDataSlotEXT : nullptr;
- }
- if (!strcmp(name, "vkSetPrivateDataEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkSetPrivateDataEXT : nullptr;
- }
- if (!strcmp(name, "vkGetPrivateDataEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkGetPrivateDataEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetPatchControlPointsEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetRasterizerDiscardEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetDepthBiasEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetLogicOpEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetPrimitiveRestartEnableEXT : nullptr;
- }
-#endif
-#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkFreeMemorySyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetLinearImageLayoutGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetLinearImageLayout2GOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetBlobGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetBlobGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
- }
+#ifdef VK_QNX_external_memory_screen_buffer
#endif
- return nullptr;
-}
-
-} // namespace vk
-} // namespace gfxstream
diff --git a/guest/vulkan_enc/gfxstream_vk_private.cpp b/guest/vulkan_enc/gfxstream_vk_private.cpp
new file mode 100644
index 0000000..ba552ea
--- /dev/null
+++ b/guest/vulkan_enc/gfxstream_vk_private.cpp
@@ -0,0 +1,53 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gfxstream_vk_private.h"
+
+#include "vk_sync_dummy.h"
+
+static bool isNoopSemaphore(gfxstream_vk_semaphore* semaphore) {
+ /* Under the assumption that Mesa VK runtime queue submission is used, WSI flow
+ * sets this temporary state to a dummy sync type (when no explicit dma-buf
+ * synchronization is available). For gfxstream case, ignore this semaphore
+ * when this is the case. Synchronization will be done on the host.
+ */
+ return (semaphore && semaphore->vk.temporary &&
+ vk_sync_type_is_dummy(semaphore->vk.temporary->type));
+}
+
+std::vector<VkSemaphore> transformVkSemaphoreList(const VkSemaphore* pSemaphores,
+ uint32_t semaphoreCount) {
+ std::vector<VkSemaphore> outSemaphores;
+ for (uint32_t j = 0; j < semaphoreCount; ++j) {
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, pSemaphores[j]);
+ if (!isNoopSemaphore(gfxstream_semaphore)) {
+ outSemaphores.push_back(gfxstream_semaphore->internal_object);
+ }
+ }
+ return outSemaphores;
+}
+
+std::vector<VkSemaphoreSubmitInfo> transformVkSemaphoreSubmitInfoList(
+ const VkSemaphoreSubmitInfo* pSemaphoreSubmitInfos, uint32_t semaphoreSubmitInfoCount) {
+ std::vector<VkSemaphoreSubmitInfo> outSemaphoreSubmitInfo;
+ for (uint32_t j = 0; j < semaphoreSubmitInfoCount; ++j) {
+ VkSemaphoreSubmitInfo outInfo = pSemaphoreSubmitInfos[j];
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, outInfo.semaphore);
+ if (!isNoopSemaphore(gfxstream_semaphore)) {
+ outInfo.semaphore = gfxstream_semaphore->internal_object;
+ outSemaphoreSubmitInfo.push_back(outInfo);
+ }
+ }
+ return outSemaphoreSubmitInfo;
+}
diff --git a/guest/vulkan_enc/gfxstream_vk_private.h b/guest/vulkan_enc/gfxstream_vk_private.h
new file mode 100644
index 0000000..5062854
--- /dev/null
+++ b/guest/vulkan_enc/gfxstream_vk_private.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright © 2023 Google Inc.
+ *
+ * derived from panvk_private.h driver which is:
+ * Copyright © 2021 Collabora Ltd.
+ * Copyright © 2016 Red Hat.
+ * Copyright © 2016 Bas Nieuwenhuizen
+ * Copyright © 2015 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef GFXSTREAM_VK_PRIVATE_H
+#define GFXSTREAM_VK_PRIVATE_H
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vulkan/vk_icd.h>
+#include <vulkan/vulkan.h>
+
+#include <vector>
+
+#include "gfxstream_vk_entrypoints.h"
+#include "vk_alloc.h"
+#include "vk_buffer.h"
+#include "vk_buffer_view.h"
+#include "vk_command_buffer.h"
+#include "vk_command_pool.h"
+#include "vk_descriptor_update_template.h"
+#include "vk_device.h"
+#include "vk_device_memory.h"
+#include "vk_extensions.h"
+#include "vk_fence.h"
+#include "vk_image.h"
+#include "vk_instance.h"
+#include "vk_log.h"
+#include "vk_object.h"
+#include "vk_physical_device.h"
+#include "vk_query_pool.h"
+#include "vk_queue.h"
+#include "vk_semaphore.h"
+#include "vulkan/wsi/wsi_common.h"
+
+struct gfxstream_vk_instance {
+ struct vk_instance vk;
+ uint32_t api_version;
+ VkInstance internal_object;
+};
+
+struct gfxstream_vk_physical_device {
+ struct vk_physical_device vk;
+
+ struct wsi_device wsi_device;
+ const struct vk_sync_type* sync_types[2];
+ struct gfxstream_vk_instance* instance;
+ VkPhysicalDevice internal_object;
+};
+
+struct gfxstream_vk_device {
+ struct vk_device vk;
+
+ struct vk_device_dispatch_table cmd_dispatch;
+ struct gfxstream_vk_physical_device* physical_device;
+ VkDevice internal_object;
+};
+
+struct gfxstream_vk_queue {
+ struct vk_queue vk;
+ struct gfxstream_vk_device* device;
+ VkQueue internal_object;
+};
+
+struct gfxstream_vk_pipeline_cache {
+ struct vk_object_base base;
+ VkPipelineCache internal_object;
+};
+
+struct gfxstream_vk_device_memory {
+ struct vk_device_memory vk;
+ VkDeviceMemory internal_object;
+};
+
+struct gfxstream_vk_descriptor_set_layout {
+ struct vk_object_base base;
+ VkDescriptorSetLayout internal_object;
+};
+
+struct gfxstream_vk_pipeline_layout {
+ struct vk_object_base base;
+ VkPipelineLayout internal_object;
+};
+
+struct gfxstream_vk_descriptor_pool {
+ struct vk_object_base base;
+ VkDescriptorPool internal_object;
+};
+
+struct gfxstream_vk_buffer {
+ struct vk_buffer vk;
+ VkBuffer internal_object;
+};
+
+struct gfxstream_vk_command_pool {
+ struct vk_command_pool vk;
+ VkCommandPool internal_object;
+};
+
+struct gfxstream_vk_command_buffer {
+ struct vk_command_buffer vk;
+ VkCommandBuffer internal_object;
+};
+
+struct gfxstream_vk_event {
+ struct vk_object_base base;
+ VkEvent internal_object;
+};
+
+struct gfxstream_vk_pipeline {
+ struct vk_object_base base;
+ VkPipeline internal_object;
+};
+
+struct gfxstream_vk_image {
+ struct vk_image vk;
+ VkImage internal_object;
+};
+
+struct gfxstream_vk_image_view {
+ struct vk_image_view vk;
+ VkImageView internal_object;
+};
+
+struct gfxstream_vk_buffer_view {
+ struct vk_buffer_view vk;
+ VkBufferView internal_object;
+};
+
+struct gfxstream_vk_framebuffer {
+ struct vk_object_base base;
+ VkFramebuffer internal_object;
+};
+
+struct gfxstream_vk_render_pass {
+ struct vk_object_base base;
+ VkRenderPass internal_object;
+};
+
+struct gfxstream_vk_fence {
+ struct vk_fence vk;
+ VkFence internal_object;
+};
+
+struct gfxstream_vk_semaphore {
+ struct vk_semaphore vk;
+ VkSemaphore internal_object;
+};
+
+struct gfxstream_vk_query_pool {
+ struct vk_query_pool vk;
+ VkQueryPool internal_object;
+};
+
+struct gfxstream_vk_shader_module {
+ struct vk_object_base base;
+ VkShaderModule internal_object;
+};
+
+struct gfxstream_vk_descriptor_update_template {
+ struct vk_object_base base;
+ VkDescriptorUpdateTemplate internal_object;
+};
+
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_command_buffer, vk.base, VkCommandBuffer,
+ VK_OBJECT_TYPE_COMMAND_BUFFER)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_device, vk.base, VkDevice, VK_OBJECT_TYPE_DEVICE)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_instance, vk.base, VkInstance, VK_OBJECT_TYPE_INSTANCE)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_physical_device, vk.base, VkPhysicalDevice,
+ VK_OBJECT_TYPE_PHYSICAL_DEVICE)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_queue, vk.base, VkQueue, VK_OBJECT_TYPE_QUEUE)
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_command_pool, vk.base, VkCommandPool,
+ VK_OBJECT_TYPE_COMMAND_POOL)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_buffer, vk.base, VkBuffer, VK_OBJECT_TYPE_BUFFER)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_buffer_view, vk.base, VkBufferView,
+ VK_OBJECT_TYPE_BUFFER_VIEW)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_pool, base, VkDescriptorPool,
+ VK_OBJECT_TYPE_DESCRIPTOR_POOL)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_set_layout, base, VkDescriptorSetLayout,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_device_memory, vk.base, VkDeviceMemory,
+ VK_OBJECT_TYPE_DEVICE_MEMORY)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_event, base, VkEvent, VK_OBJECT_TYPE_EVENT)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_framebuffer, base, VkFramebuffer,
+ VK_OBJECT_TYPE_FRAMEBUFFER)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_image, vk.base, VkImage, VK_OBJECT_TYPE_IMAGE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_image_view, vk.base, VkImageView,
+ VK_OBJECT_TYPE_IMAGE_VIEW);
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline_cache, base, VkPipelineCache,
+ VK_OBJECT_TYPE_PIPELINE_CACHE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline, base, VkPipeline, VK_OBJECT_TYPE_PIPELINE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline_layout, base, VkPipelineLayout,
+ VK_OBJECT_TYPE_PIPELINE_LAYOUT)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_render_pass, base, VkRenderPass,
+ VK_OBJECT_TYPE_RENDER_PASS)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_fence, vk.base, VkFence, VK_OBJECT_TYPE_FENCE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_semaphore, vk.base, VkSemaphore,
+ VK_OBJECT_TYPE_SEMAPHORE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_query_pool, vk.base, VkQueryPool,
+ VK_OBJECT_TYPE_QUERY_POOL)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_shader_module, base, VkShaderModule,
+ VK_OBJECT_TYPE_SHADER_MODULE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_update_template, base,
+ VkDescriptorUpdateTemplate,
+ VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE)
+
+VkResult gfxstream_vk_wsi_init(struct gfxstream_vk_physical_device* physical_device);
+
+void gfxstream_vk_wsi_finish(struct gfxstream_vk_physical_device* physical_device);
+
+std::vector<VkSemaphore> transformVkSemaphoreList(const VkSemaphore* pSemaphores,
+ uint32_t semaphoreCount);
+
+std::vector<VkSemaphoreSubmitInfo> transformVkSemaphoreSubmitInfoList(
+ const VkSemaphoreSubmitInfo* pSemaphoreSubmitInfos, uint32_t semaphoreSubmitInfoCount);
+
+#endif /* GFXSTREAM_VK_PRIVATE_H */
diff --git a/guest/vulkan_enc/goldfish_vk_counting_guest.cpp b/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
index baa197b..0ca2b28 100644
--- a/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
@@ -6411,6 +6411,39 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
+ *count += sizeof(VkBool32);
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -7232,6 +7265,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void count_extension_struct(uint32_t featureBits, VkStructureType rootType,
const void* structExtension, size_t* count) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -8127,6 +8162,24 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension),
+ count);
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_counting_guest.h b/guest/vulkan_enc/goldfish_vk_counting_guest.h
index 3b6e71a..d8db6b2 100644
--- a/guest/vulkan_enc/goldfish_vk_counting_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_counting_guest.h
@@ -1512,6 +1512,16 @@
count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount, size_t* count);
+
+void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount, size_t* count);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -1799,6 +1809,8 @@
const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toCount, size_t* count);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index a9edede..23cc624 100644
--- a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -7395,6 +7395,54 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -8513,6 +8561,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
const void* structExtension, void* structExtension_out) {
if (!structExtension) {
@@ -9462,6 +9512,25 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
index f6a7fdb..da8bc90 100644
--- a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -1653,6 +1653,18 @@
deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* to);
+
+void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* to);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -1975,6 +1987,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* to);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index 0a20303..979fed2 100644
--- a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -140,6 +140,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -210,6 +212,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
uint32_t goldfish_vk_struct_type(const void* structExtension) {
const uint32_t asStructType = *(reinterpret_cast<const uint32_t*>(structExtension));
return asStructType;
@@ -609,6 +613,14 @@
return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
@@ -1154,6 +1166,14 @@
return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
diff --git a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h
index 0064c66..71c7390 100644
--- a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -160,6 +160,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -230,6 +232,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index a36522b..3edd322 100644
--- a/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -12008,6 +12008,60 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -13393,6 +13447,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void marshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
const void* structExtension) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -14212,6 +14268,22 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -15295,6 +15367,21 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_marshaling_guest.h b/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
index 39877d3..008d90e 100644
--- a/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -3148,6 +3148,24 @@
unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -3706,6 +3724,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
const char* api_opcode_to_string(const uint32_t opcode);
#define OP_vkFirst_old 20000
diff --git a/guest/vulkan_enc/goldfish_vk_private_defs.h b/guest/vulkan_enc/goldfish_vk_private_defs.h
index 0867320..d50e6f1 100644
--- a/guest/vulkan_enc/goldfish_vk_private_defs.h
+++ b/guest/vulkan_enc/goldfish_vk_private_defs.h
@@ -23,16 +23,16 @@
#ifdef __cplusplus
-template<class T, typename F>
+template <class T, typename F>
bool arrayany(const T* arr, uint32_t begin, uint32_t end, const F& func) {
const T* e = arr + end;
return std::find_if(arr + begin, e, func) != e;
}
-#define DEFINE_ALIAS_FUNCTION(ORIGINAL_FN, ALIAS_FN) \
-template <typename... Args> \
-inline auto ALIAS_FN(Args&&... args) -> decltype(ORIGINAL_FN(std::forward<Args>(args)...)) { \
- return ORIGINAL_FN(std::forward<Args>(args)...); \
-}
+#define DEFINE_ALIAS_FUNCTION(ORIGINAL_FN, ALIAS_FN) \
+ template <typename... Args> \
+ inline auto ALIAS_FN(Args&&... args) -> decltype(ORIGINAL_FN(std::forward<Args>(args)...)) { \
+ return ORIGINAL_FN(std::forward<Args>(args)...); \
+ }
#endif
diff --git a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
index 71f3a94..6c223e7 100644
--- a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
@@ -8086,6 +8086,41 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ *ptr += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -8994,6 +9029,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void reservedmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
const void* structExtension, uint8_t** ptr) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -9880,6 +9917,24 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
index f1a8a1c..ac2de29 100644
--- a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
@@ -1685,6 +1685,16 @@
reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -1991,6 +2001,8 @@
uint8_t** ptr);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_transform_guest.cpp b/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
index 8eb7cd7..8aa5c7d 100644
--- a/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -6870,6 +6870,46 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ ResourceTracker* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ ResourceTracker* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -7826,6 +7866,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void transform_tohost_extension_struct(ResourceTracker* resourceTracker,
void* structExtension_out) {
if (!structExtension_out) {
@@ -8600,6 +8642,21 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -9631,6 +9688,21 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_transform_guest.h b/guest/vulkan_enc/goldfish_vk_transform_guest.h
index 6dff96d..fb8ef89 100644
--- a/guest/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_transform_guest.h
@@ -2663,6 +2663,22 @@
transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+
+void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ ResourceTracker* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ ResourceTracker* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -3131,6 +3147,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/guest/vulkan_enc/meson.build b/guest/vulkan_enc/meson.build
index c94dd0d..33709bb 100644
--- a/guest/vulkan_enc/meson.build
+++ b/guest/vulkan_enc/meson.build
@@ -1,6 +1,17 @@
# Copyright 2022 Android Open Source Project
# SPDX-License-Identifier: MIT
+gfxstream_vk_entrypoints = custom_target(
+ 'gfxstream_vk_entrypoints',
+ input : [vk_entrypoints_gen, vk_api_xml],
+ output : ['gfxstream_vk_entrypoints.h', 'gfxstream_vk_entrypoints.c'],
+ command : [
+ prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--proto', '--weak',
+ '--out-h', '@OUTPUT0@', '--out-c', '@OUTPUT1@', '--prefix', 'gfxstream_vk',
+ '--beta', with_vulkan_beta.to_string()
+ ],
+)
+
files_lib_vulkan_enc = files(
'CommandBufferStagingStream.cpp',
'DescriptorSetVirtualization.cpp',
@@ -19,16 +30,5 @@
'goldfish_vk_marshaling_guest.cpp',
'goldfish_vk_reserved_marshaling_guest.cpp',
'goldfish_vk_transform_guest.cpp',
-)
-
-lib_vulkan_enc = static_library(
- 'vulkan_enc',
- files_lib_vulkan_enc,
- cpp_args: cpp_args,
- include_directories: [inc_android_emu, inc_guest_iostream, inc_android_compat,
- inc_opengl_codec, inc_render_enc, inc_system,
- inc_goldfish_address_space, inc_platform,
- inc_vulkan_headers, inc_opengl_headers, inc_codec_common],
- link_with: [lib_platform],
- dependencies: dependency('libdrm'),
+ 'gfxstream_vk_private.cpp',
)
diff --git a/guest/vulkan_enc/vk_format_info.h b/guest/vulkan_enc/vk_format_info.h
index 9fbc82a..2d5d84e 100644
--- a/guest/vulkan_enc/vk_format_info.h
+++ b/guest/vulkan_enc/vk_format_info.h
@@ -35,8 +35,8 @@
HAL_PIXEL_FORMAT_YV12 = 842094169,
};
#endif
-#include <vulkan/vulkan.h>
#include <vndk/hardware_buffer.h>
+#include <vulkan/vulkan.h>
namespace gfxstream {
namespace vk {
@@ -55,165 +55,149 @@
// formats such as AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 could be
// either VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM or
// VK_FORMAT_G8_B8R8_2PLANE_420_UNORM.
-static inline VkFormat
-vk_format_from_android(unsigned android_format)
-{
- switch (android_format) {
- case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
- return VK_FORMAT_R8G8B8A8_UNORM;
- case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
- return VK_FORMAT_R8G8B8A8_UNORM;
- case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
- return VK_FORMAT_R8G8B8_UNORM;
- case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
- return VK_FORMAT_R5G6B5_UNORM_PACK16;
- case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
- return VK_FORMAT_R16G16B16A16_SFLOAT;
- case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
- return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
- case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
- case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
- return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
+static inline VkFormat vk_format_from_android(unsigned android_format) {
+ switch (android_format) {
+ case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+ return VK_FORMAT_R8G8B8A8_UNORM;
+ case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+ return VK_FORMAT_R8G8B8A8_UNORM;
+ case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+ return VK_FORMAT_R8G8B8_UNORM;
+ case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+ return VK_FORMAT_R5G6B5_UNORM_PACK16;
+ case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+ return VK_FORMAT_R16G16B16A16_SFLOAT;
+ case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+ return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+ case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
+ case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
+ return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
#if __ANDROID_API__ >= 30
- case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
- return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
+ case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
+ return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
#endif
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- case HAL_PIXEL_FORMAT_YV12:
- case OMX_COLOR_FormatYUV420Planar:
- return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
- case AHARDWAREBUFFER_FORMAT_BLOB:
+ case HAL_PIXEL_FORMAT_YV12:
+ case OMX_COLOR_FormatYUV420Planar:
+ return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
+ case AHARDWAREBUFFER_FORMAT_BLOB:
#endif
- default:
- return VK_FORMAT_UNDEFINED;
- }
+ default:
+ return VK_FORMAT_UNDEFINED;
+ }
}
-static inline unsigned
-android_format_from_vk(VkFormat vk_format)
-{
- switch (vk_format) {
- case VK_FORMAT_R8G8B8A8_UNORM:
- return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
- case VK_FORMAT_R8G8B8_UNORM:
- return AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM;
- case VK_FORMAT_R5G6B5_UNORM_PACK16:
- return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
- case VK_FORMAT_R16G16B16A16_SFLOAT:
- return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
- case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
- return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
- case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
- return HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL;
- case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
- return HAL_PIXEL_FORMAT_YV12;
- default:
- return AHARDWAREBUFFER_FORMAT_BLOB;
- }
+static inline unsigned android_format_from_vk(VkFormat vk_format) {
+ switch (vk_format) {
+ case VK_FORMAT_R8G8B8A8_UNORM:
+ return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+ case VK_FORMAT_R8G8B8_UNORM:
+ return AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM;
+ case VK_FORMAT_R5G6B5_UNORM_PACK16:
+ return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
+ case VK_FORMAT_R16G16B16A16_SFLOAT:
+ return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
+ case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+ return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
+ case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ return HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL;
+ case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ return HAL_PIXEL_FORMAT_YV12;
+ default:
+ return AHARDWAREBUFFER_FORMAT_BLOB;
+ }
}
-static inline bool
-android_format_is_yuv(unsigned android_format)
-{
- switch (android_format) {
- case AHARDWAREBUFFER_FORMAT_BLOB:
- case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
- case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
- case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
- case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
- case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
- case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
- case AHARDWAREBUFFER_FORMAT_D16_UNORM:
- case AHARDWAREBUFFER_FORMAT_D24_UNORM:
- case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
- case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
- case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
- case AHARDWAREBUFFER_FORMAT_S8_UINT:
- return false;
- case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
- case OMX_COLOR_FormatYUV420Planar:
- case HAL_PIXEL_FORMAT_YV12:
+static inline bool android_format_is_yuv(unsigned android_format) {
+ switch (android_format) {
+ case AHARDWAREBUFFER_FORMAT_BLOB:
+ case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+ case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+ case AHARDWAREBUFFER_FORMAT_D16_UNORM:
+ case AHARDWAREBUFFER_FORMAT_D24_UNORM:
+ case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
+ case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
+ case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
+ case AHARDWAREBUFFER_FORMAT_S8_UINT:
+ return false;
+ case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
+ case OMX_COLOR_FormatYUV420Planar:
+ case HAL_PIXEL_FORMAT_YV12:
#if __ANDROID_API__ >= 30
- case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
+ case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
#endif
- case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
- return true;
- default:
- ALOGE("%s: unhandled format: %d", __FUNCTION__, android_format);
- return false;
- }
+ case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
+ return true;
+ default:
+ ALOGE("%s: unhandled format: %d", __FUNCTION__, android_format);
+ return false;
+ }
}
-static inline VkImageAspectFlags
-vk_format_aspects(VkFormat format)
-{
- switch (format) {
- case VK_FORMAT_UNDEFINED:
- return 0;
+static inline VkImageAspectFlags vk_format_aspects(VkFormat format) {
+ switch (format) {
+ case VK_FORMAT_UNDEFINED:
+ return 0;
- case VK_FORMAT_S8_UINT:
- return VK_IMAGE_ASPECT_STENCIL_BIT;
+ case VK_FORMAT_S8_UINT:
+ return VK_IMAGE_ASPECT_STENCIL_BIT;
- case VK_FORMAT_D16_UNORM_S8_UINT:
- case VK_FORMAT_D24_UNORM_S8_UINT:
- case VK_FORMAT_D32_SFLOAT_S8_UINT:
- return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+ case VK_FORMAT_D16_UNORM_S8_UINT:
+ case VK_FORMAT_D24_UNORM_S8_UINT:
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
- case VK_FORMAT_D16_UNORM:
- case VK_FORMAT_X8_D24_UNORM_PACK32:
- case VK_FORMAT_D32_SFLOAT:
- return VK_IMAGE_ASPECT_DEPTH_BIT;
+ case VK_FORMAT_D16_UNORM:
+ case VK_FORMAT_X8_D24_UNORM_PACK32:
+ case VK_FORMAT_D32_SFLOAT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT;
- case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
- case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
- case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
- case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
- case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
- case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
- case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
- case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
- case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
- case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
- case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
- case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
- return (VK_IMAGE_ASPECT_PLANE_0_BIT |
- VK_IMAGE_ASPECT_PLANE_1_BIT |
- VK_IMAGE_ASPECT_PLANE_2_BIT);
+ case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+ case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
+ return (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT |
+ VK_IMAGE_ASPECT_PLANE_2_BIT);
- case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
- case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
- case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
- case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
- case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
- case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
- case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
- case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
- return (VK_IMAGE_ASPECT_PLANE_0_BIT |
- VK_IMAGE_ASPECT_PLANE_1_BIT);
+ case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+ case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+ return (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT);
- default:
- return VK_IMAGE_ASPECT_COLOR_BIT;
- }
+ default:
+ return VK_IMAGE_ASPECT_COLOR_BIT;
+ }
}
-static inline bool
-vk_format_is_color(VkFormat format)
-{
- return vk_format_aspects(format) == VK_IMAGE_ASPECT_COLOR_BIT;
+static inline bool vk_format_is_color(VkFormat format) {
+ return vk_format_aspects(format) == VK_IMAGE_ASPECT_COLOR_BIT;
}
-static inline bool
-vk_format_is_depth_or_stencil(VkFormat format)
-{
- const VkImageAspectFlags aspects = vk_format_aspects(format);
- return aspects & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
+static inline bool vk_format_is_depth_or_stencil(VkFormat format) {
+ const VkImageAspectFlags aspects = vk_format_aspects(format);
+ return aspects & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
}
-static inline bool
-vk_format_has_depth(VkFormat format)
-{
- const VkImageAspectFlags aspects = vk_format_aspects(format);
- return aspects & VK_IMAGE_ASPECT_DEPTH_BIT;
+static inline bool vk_format_has_depth(VkFormat format) {
+ const VkImageAspectFlags aspects = vk_format_aspects(format);
+ return aspects & VK_IMAGE_ASPECT_DEPTH_BIT;
}
} // namespace vk
diff --git a/guest/vulkan_enc/vk_platform_compat.h b/guest/vulkan_enc/vk_platform_compat.h
index e182bac..38f78cd 100644
--- a/guest/vulkan_enc/vk_platform_compat.h
+++ b/guest/vulkan_enc/vk_platform_compat.h
@@ -18,13 +18,13 @@
#if VK_HEADER_VERSION < 76
typedef struct VkBaseOutStructure {
- VkStructureType sType;
- struct VkBaseOutStructure* pNext;
+ VkStructureType sType;
+ struct VkBaseOutStructure* pNext;
} VkBaseOutStructure;
typedef struct VkBaseInStructure {
- VkStructureType sType;
- const struct VkBaseInStructure* pNext;
+ VkStructureType sType;
+ const struct VkBaseInStructure* pNext;
} VkBaseInStructure;
-#endif // VK_HEADER_VERSION < 76
+#endif // VK_HEADER_VERSION < 76
diff --git a/guest/vulkan_enc/vk_struct_id.h b/guest/vulkan_enc/vk_struct_id.h
index 0ca2ff5..eaae46b 100644
--- a/guest/vulkan_enc/vk_struct_id.h
+++ b/guest/vulkan_enc/vk_struct_id.h
@@ -20,18 +20,25 @@
#include "vk_android_native_buffer_gfxstream.h"
#include "vulkan_gfxstream.h"
-namespace gfxstream {
-namespace vk {
+// anonymous
+namespace {
-template <class T> struct vk_get_vk_struct_id;
+template <class T>
+struct vk_get_vk_struct_id;
-#define REGISTER_VK_STRUCT_ID(T, ID) \
- template <> struct vk_get_vk_struct_id<T> { static constexpr VkStructureType id = ID; }
+#define REGISTER_VK_STRUCT_ID(T, ID) \
+ template <> \
+ struct vk_get_vk_struct_id<T> { \
+ static constexpr VkStructureType id = ID; \
+ }
#ifdef VK_USE_PLATFORM_ANDROID_KHR
-REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferPropertiesANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID);
-REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferFormatPropertiesANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID);
-REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferUsageANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID);
+REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferPropertiesANDROID,
+ VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID);
+REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferFormatPropertiesANDROID,
+ VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID);
+REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferUsageANDROID,
+ VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID);
#endif
REGISTER_VK_STRUCT_ID(VkBufferCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkImageCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
@@ -40,52 +47,79 @@
REGISTER_VK_STRUCT_ID(VkNativeBufferANDROID, VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID);
REGISTER_VK_STRUCT_ID(VkExternalFormatANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID);
#endif
-REGISTER_VK_STRUCT_ID(VkExternalMemoryBufferCreateInfo, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkExternalMemoryImageCreateInfo, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkExternalMemoryBufferCreateInfo,
+ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkExternalMemoryImageCreateInfo,
+ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkMemoryAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
-REGISTER_VK_STRUCT_ID(VkMemoryDedicatedAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
-REGISTER_VK_STRUCT_ID(VkMemoryDedicatedRequirements, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
+REGISTER_VK_STRUCT_ID(VkMemoryDedicatedAllocateInfo,
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
+REGISTER_VK_STRUCT_ID(VkMemoryDedicatedRequirements,
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
#ifdef VK_USE_PLATFORM_ANDROID_KHR
-REGISTER_VK_STRUCT_ID(VkImportAndroidHardwareBufferInfoANDROID, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);
+REGISTER_VK_STRUCT_ID(VkImportAndroidHardwareBufferInfoANDROID,
+ VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);
#endif
+REGISTER_VK_STRUCT_ID(VkImportMemoryFdInfoKHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR);
REGISTER_VK_STRUCT_ID(VkExportMemoryAllocateInfo, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
REGISTER_VK_STRUCT_ID(VkMemoryRequirements2, VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
REGISTER_VK_STRUCT_ID(VkSemaphoreCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkExportSemaphoreCreateInfoKHR, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR);
-REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkExportSemaphoreCreateInfoKHR,
+ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR);
+REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionCreateInfo,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkImportColorBufferGOOGLE, VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE);
REGISTER_VK_STRUCT_ID(VkImageViewCreateInfo, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
#ifdef VK_USE_PLATFORM_FUCHSIA
-REGISTER_VK_STRUCT_ID(VkImportMemoryBufferCollectionFUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkImportMemoryZirconHandleInfoFUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkBufferCollectionImageCreateInfoFUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkBufferCollectionBufferCreateInfoFUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkImportMemoryBufferCollectionFUCHSIA,
+ VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkImportMemoryZirconHandleInfoFUCHSIA,
+ VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkBufferCollectionImageCreateInfoFUCHSIA,
+ VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkBufferCollectionBufferCreateInfoFUCHSIA,
+ VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA);
#endif // VK_USE_PLATFORM_FUCHSIA
REGISTER_VK_STRUCT_ID(VkSamplerCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkSamplerCustomBorderColorCreateInfoEXT, VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
-REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
+REGISTER_VK_STRUCT_ID(VkSamplerCustomBorderColorCreateInfoEXT,
+ VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
+REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionInfo,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
REGISTER_VK_STRUCT_ID(VkFenceCreateInfo, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkExportFenceCreateInfo, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkImportBufferGOOGLE, VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE);
REGISTER_VK_STRUCT_ID(VkCreateBlobGOOGLE, VK_STRUCTURE_TYPE_CREATE_BLOB_GOOGLE);
-REGISTER_VK_STRUCT_ID(VkExternalImageFormatProperties, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceImageFormatInfo2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalImageFormatInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
+REGISTER_VK_STRUCT_ID(VkExternalImageFormatProperties,
+ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceImageFormatInfo2,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalImageFormatInfo,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
REGISTER_VK_STRUCT_ID(VkSemaphoreTypeCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkPhysicalDeviceFeatures2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
REGISTER_VK_STRUCT_ID(VkPhysicalDeviceProperties2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT);
REGISTER_VK_STRUCT_ID(VkMemoryAllocateFlagsInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO);
-REGISTER_VK_STRUCT_ID(VkMemoryOpaqueCaptureAddressAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
+REGISTER_VK_STRUCT_ID(VkMemoryOpaqueCaptureAddressAllocateInfo,
+ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
REGISTER_VK_STRUCT_ID(VkBindImageMemoryInfo, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
-REGISTER_VK_STRUCT_ID(VkBindImageMemorySwapchainInfoKHR, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR);
-REGISTER_VK_STRUCT_ID(VkBufferOpaqueCaptureAddressCreateInfo, VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkBufferDeviceAddressCreateInfoEXT, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT);
-REGISTER_VK_STRUCT_ID(VkGraphicsPipelineCreateInfo, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkPipelineRenderingCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalSemaphoreInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
+REGISTER_VK_STRUCT_ID(VkBindImageMemorySwapchainInfoKHR,
+ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR);
+REGISTER_VK_STRUCT_ID(VkBufferOpaqueCaptureAddressCreateInfo,
+ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkBufferDeviceAddressCreateInfoEXT,
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT);
+REGISTER_VK_STRUCT_ID(VkGraphicsPipelineCreateInfo,
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkPipelineRenderingCreateInfo,
+ VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalSemaphoreInfo,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
+REGISTER_VK_STRUCT_ID(VkRenderPassBeginInfo, VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO);
+REGISTER_VK_STRUCT_ID(VkRenderPassAttachmentBeginInfo,
+ VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
#undef REGISTER_VK_STRUCT_ID
-} // namespace vk
-} // namespace gfxstream
+} // namespace
diff --git a/guest/vulkan_enc/vk_util.h b/guest/vulkan_enc/vk_util.h
index 2e3267f..e18bdde 100644
--- a/guest/vulkan_enc/vk_util.h
+++ b/guest/vulkan_enc/vk_util.h
@@ -25,29 +25,29 @@
/* common inlines and macros for vulkan drivers */
-#include <vulkan/vulkan.h>
#include <stdlib.h>
+#include <vulkan/vulkan.h>
+
#include "vk_struct_id.h"
-namespace gfxstream {
-namespace vk {
+namespace { // anonymous
struct vk_struct_common {
VkStructureType sType;
- struct vk_struct_common *pNext;
+ struct vk_struct_common* pNext;
};
struct vk_struct_chain_iterator {
vk_struct_common* value;
};
-#define vk_foreach_struct(__iter, __start) \
- for (struct vk_struct_common *__iter = (struct vk_struct_common *)(__start); \
- __iter; __iter = __iter->pNext)
+#define vk_foreach_struct(__iter, __start) \
+ for (struct vk_struct_common* __iter = (struct vk_struct_common*)(__start); __iter; \
+ __iter = __iter->pNext)
-#define vk_foreach_struct_const(__iter, __start) \
- for (const struct vk_struct_common *__iter = (const struct vk_struct_common *)(__start); \
- __iter; __iter = __iter->pNext)
+#define vk_foreach_struct_const(__iter, __start) \
+ for (const struct vk_struct_common* __iter = (const struct vk_struct_common*)(__start); \
+ __iter; __iter = __iter->pNext)
/**
* A wrapper for a Vulkan output array. A Vulkan output array is one that
@@ -79,92 +79,84 @@
* }
*/
struct __vk_outarray {
- /** May be null. */
- void *data;
+ /** May be null. */
+ void* data;
- /**
- * Capacity, in number of elements. Capacity is unlimited (UINT32_MAX) if
- * data is null.
- */
- uint32_t cap;
+ /**
+ * Capacity, in number of elements. Capacity is unlimited (UINT32_MAX) if
+ * data is null.
+ */
+ uint32_t cap;
- /**
- * Count of elements successfully written to the array. Every write is
- * considered successful if data is null.
- */
- uint32_t *filled_len;
+ /**
+ * Count of elements successfully written to the array. Every write is
+ * considered successful if data is null.
+ */
+ uint32_t* filled_len;
- /**
- * Count of elements that would have been written to the array if its
- * capacity were sufficient. Vulkan functions often return VK_INCOMPLETE
- * when `*filled_len < wanted_len`.
- */
- uint32_t wanted_len;
+ /**
+ * Count of elements that would have been written to the array if its
+ * capacity were sufficient. Vulkan functions often return VK_INCOMPLETE
+ * when `*filled_len < wanted_len`.
+ */
+ uint32_t wanted_len;
};
-static inline void
-__vk_outarray_init(struct __vk_outarray *a,
- void *data, uint32_t * len)
-{
- a->data = data;
- a->cap = *len;
- a->filled_len = len;
- *a->filled_len = 0;
- a->wanted_len = 0;
+static inline void __vk_outarray_init(struct __vk_outarray* a, void* data, uint32_t* len) {
+ a->data = data;
+ a->cap = *len;
+ a->filled_len = len;
+ *a->filled_len = 0;
+ a->wanted_len = 0;
- if (a->data == NULL)
- a->cap = UINT32_MAX;
+ if (a->data == NULL) a->cap = UINT32_MAX;
}
-static inline VkResult
-__vk_outarray_status(const struct __vk_outarray *a)
-{
- if (*a->filled_len < a->wanted_len)
- return VK_INCOMPLETE;
- else
- return VK_SUCCESS;
+static inline VkResult __vk_outarray_status(const struct __vk_outarray* a) {
+ if (*a->filled_len < a->wanted_len)
+ return VK_INCOMPLETE;
+ else
+ return VK_SUCCESS;
}
-static inline void *
-__vk_outarray_next(struct __vk_outarray *a, size_t elem_size)
-{
- void *p = NULL;
+static inline void* __vk_outarray_next(struct __vk_outarray* a, size_t elem_size) {
+ void* p = NULL;
- a->wanted_len += 1;
+ a->wanted_len += 1;
- if (*a->filled_len >= a->cap)
- return NULL;
+ if (*a->filled_len >= a->cap) return NULL;
- if (a->data != NULL)
- p = ((uint8_t*)a->data) + (*a->filled_len) * elem_size;
+ if (a->data != NULL) p = ((uint8_t*)a->data) + (*a->filled_len) * elem_size;
- *a->filled_len += 1;
+ *a->filled_len += 1;
- return p;
+ return p;
}
-#define vk_outarray(elem_t) \
- struct { \
- struct __vk_outarray base; \
- elem_t meta[]; \
- }
+#define vk_outarray(elem_t) \
+ struct { \
+ struct __vk_outarray base; \
+ elem_t meta[]; \
+ }
#define vk_outarray_typeof_elem(a) __typeof__((a)->meta[0])
#define vk_outarray_sizeof_elem(a) sizeof((a)->meta[0])
-#define vk_outarray_init(a, data, len) \
- __vk_outarray_init(&(a)->base, (data), (len))
+#define vk_outarray_init(a, data, len) __vk_outarray_init(&(a)->base, (data), (len))
-#define VK_OUTARRAY_MAKE(name, data, len) \
- vk_outarray(__typeof__((data)[0])) name; \
- vk_outarray_init(&name, (data), (len))
+#define VK_OUTARRAY_MAKE(name, data, len) \
+ vk_outarray(__typeof__((data)[0])) name; \
+ vk_outarray_init(&name, (data), (len))
-#define vk_outarray_status(a) \
- __vk_outarray_status(&(a)->base)
+#define VK_OUTARRAY_MAKE_TYPED(type, name, data, len) \
+ vk_outarray(type) name; \
+ vk_outarray_init(&name, (data), (len))
-#define vk_outarray_next(a) \
- ((vk_outarray_typeof_elem(a) *) \
- __vk_outarray_next(&(a)->base, vk_outarray_sizeof_elem(a)))
+#define vk_outarray_status(a) __vk_outarray_status(&(a)->base)
+
+#define vk_outarray_next(a) vk_outarray_next_typed(vk_outarray_typeof_elem(a), a)
+#define vk_outarray_next_typed(type, a) \
+ ((type*)__vk_outarray_next(&(a)->base, vk_outarray_sizeof_elem(a)))
/**
* Append to a Vulkan output array.
@@ -186,31 +178,30 @@
* points to the newly appended element.
*/
#define vk_outarray_append(a, elem) \
- for (vk_outarray_typeof_elem(a) *elem = vk_outarray_next(a); \
- elem != NULL; elem = NULL)
+ for (vk_outarray_typeof_elem(a)* elem = vk_outarray_next(a); elem != NULL; elem = NULL)
-static inline void *
-__vk_find_struct(void *start, VkStructureType sType)
-{
- vk_foreach_struct(s, start) {
- if (s->sType == sType)
- return s;
- }
+#define vk_outarray_append_typed(type, a, elem) \
+ for (type* elem = vk_outarray_next_typed(type, a); elem != NULL; elem = NULL)
- return NULL;
+static inline void* __vk_find_struct(void* start, VkStructureType sType) {
+ vk_foreach_struct(s, start) {
+ if (s->sType == sType) return s;
+ }
+
+ return NULL;
}
-template <class T, class H> T* vk_find_struct(H* head)
-{
+template <class T, class H>
+T* vk_find_struct(H* head) {
(void)vk_get_vk_struct_id<H>::id;
return static_cast<T*>(__vk_find_struct(static_cast<void*>(head), vk_get_vk_struct_id<T>::id));
}
-template <class T, class H> const T* vk_find_struct(const H* head)
-{
+template <class T, class H>
+const T* vk_find_struct(const H* head) {
(void)vk_get_vk_struct_id<H>::id;
return static_cast<const T*>(__vk_find_struct(const_cast<void*>(static_cast<const void*>(head)),
- vk_get_vk_struct_id<T>::id));
+ vk_get_vk_struct_id<T>::id));
}
uint32_t vk_get_driver_version(void);
@@ -219,25 +210,25 @@
#define VK_EXT_OFFSET (1000000000UL)
#define VK_ENUM_EXTENSION(__enum) \
- ((__enum) >= VK_EXT_OFFSET ? ((((__enum) - VK_EXT_OFFSET) / 1000UL) + 1) : 0)
-#define VK_ENUM_OFFSET(__enum) \
- ((__enum) >= VK_EXT_OFFSET ? ((__enum) % 1000) : (__enum))
+ ((__enum) >= VK_EXT_OFFSET ? ((((__enum)-VK_EXT_OFFSET) / 1000UL) + 1) : 0)
+#define VK_ENUM_OFFSET(__enum) ((__enum) >= VK_EXT_OFFSET ? ((__enum) % 1000) : (__enum))
-template <class T> T vk_make_orphan_copy(const T& vk_struct) {
+template <class T>
+T vk_make_orphan_copy(const T& vk_struct) {
T copy = vk_struct;
copy.pNext = NULL;
return copy;
}
-template <class T> vk_struct_chain_iterator vk_make_chain_iterator(T* vk_struct)
-{
+template <class T>
+vk_struct_chain_iterator vk_make_chain_iterator(T* vk_struct) {
(void)vk_get_vk_struct_id<T>::id;
- vk_struct_chain_iterator result = { reinterpret_cast<vk_struct_common*>(vk_struct) };
+ vk_struct_chain_iterator result = {reinterpret_cast<vk_struct_common*>(vk_struct)};
return result;
}
-template <class T> void vk_append_struct(vk_struct_chain_iterator* i, T* vk_struct)
-{
+template <class T>
+void vk_append_struct(vk_struct_chain_iterator* i, T* vk_struct) {
(void)vk_get_vk_struct_id<T>::id;
vk_struct_common* p = i->value;
@@ -245,13 +236,12 @@
::abort();
}
- p->pNext = reinterpret_cast<vk_struct_common *>(vk_struct);
+ p->pNext = reinterpret_cast<vk_struct_common*>(vk_struct);
vk_struct->pNext = NULL;
*i = vk_make_chain_iterator(vk_struct);
}
-} // namespace vk
-} // namespace gfxstream
+} // namespace
#endif /* VK_UTIL_H */
diff --git a/guest/vulkan_enc_unit_tests/Android.bp b/guest/vulkan_enc_unit_tests/Android.bp
index 6866fd9..5787914 100644
--- a/guest/vulkan_enc_unit_tests/Android.bp
+++ b/guest/vulkan_enc_unit_tests/Android.bp
@@ -32,10 +32,11 @@
"gfxstream_vulkan_headers",
"libgfxstream_guest_iostream",
],
+ shared_libs: [
+ "liblog",
+ ],
static_libs: [
"libgmock",
- ],
- shared_libs: [
"libvulkan_enc",
],
}
diff --git a/host/vulkan/VkDecoder.cpp b/host/vulkan/VkDecoder.cpp
index 8be2602..b72880e 100644
--- a/host/vulkan/VkDecoder.cpp
+++ b/host/vulkan/VkDecoder.cpp
@@ -18268,6 +18268,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -21397,6 +21399,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
default: {
m_pool.freeAll();
return ptr - (unsigned char*)buf;
diff --git a/host/vulkan/VkDecoder.h b/host/vulkan/VkDecoder.h
index 1e91469..ed04fe1 100644
--- a/host/vulkan/VkDecoder.h
+++ b/host/vulkan/VkDecoder.h
@@ -174,6 +174,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -244,3 +246,5 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
diff --git a/host/vulkan/VkDecoderSnapshot.cpp b/host/vulkan/VkDecoderSnapshot.cpp
index 21f8b73..d901f76 100644
--- a/host/vulkan/VkDecoderSnapshot.cpp
+++ b/host/vulkan/VkDecoderSnapshot.cpp
@@ -2408,6 +2408,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -2841,6 +2843,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
private:
android::base::Lock mLock;
diff --git a/host/vulkan/VkDecoderSnapshot.h b/host/vulkan/VkDecoderSnapshot.h
index b3c8991..47e4a20 100644
--- a/host/vulkan/VkDecoderSnapshot.h
+++ b/host/vulkan/VkDecoderSnapshot.h
@@ -1315,6 +1315,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -1605,6 +1607,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
private:
class Impl;
diff --git a/host/vulkan/VkSubDecoder.cpp b/host/vulkan/VkSubDecoder.cpp
index 0113c8e..194cf92 100644
--- a/host/vulkan/VkSubDecoder.cpp
+++ b/host/vulkan/VkSubDecoder.cpp
@@ -2724,6 +2724,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -3138,6 +3140,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
default: {
GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
<< "Unrecognized opcode " << opcode;
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
index 565fec2..841a6d7 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
@@ -7602,6 +7602,54 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -8873,6 +8921,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
const void* structExtension, void* structExtension_out) {
if (!structExtension) {
@@ -9852,6 +9902,25 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
index f1d2e8a..b293359 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
@@ -1677,6 +1677,18 @@
deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* to);
+
+void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* to);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -2024,6 +2036,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* to);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
index 89e40e3..f3bff18 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
@@ -145,6 +145,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -215,6 +217,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dlSymFunc,
VulkanDispatch* out) {
@@ -946,6 +950,10 @@
out->vkQueueSubmitAsync2GOOGLE =
(PFN_vkQueueSubmitAsync2GOOGLE)dlSymFunc(lib, "vkQueueSubmitAsync2GOOGLE");
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+ out->vkGetScreenBufferPropertiesQNX =
+ (PFN_vkGetScreenBufferPropertiesQNX)dlSymFunc(lib, "vkGetScreenBufferPropertiesQNX");
+#endif
}
void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
@@ -1886,6 +1894,11 @@
out->vkQueueSubmitAsync2GOOGLE = (PFN_vkQueueSubmitAsync2GOOGLE)vk->vkGetInstanceProcAddr(
instance, "vkQueueSubmitAsync2GOOGLE");
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+ out->vkGetScreenBufferPropertiesQNX =
+ (PFN_vkGetScreenBufferPropertiesQNX)vk->vkGetInstanceProcAddr(
+ instance, "vkGetScreenBufferPropertiesQNX");
+#endif
}
void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, VulkanDispatch* out) {
@@ -2799,6 +2812,11 @@
out->vkQueueSubmitAsync2GOOGLE =
(PFN_vkQueueSubmitAsync2GOOGLE)vk->vkGetDeviceProcAddr(device, "vkQueueSubmitAsync2GOOGLE");
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+ out->vkGetScreenBufferPropertiesQNX =
+ (PFN_vkGetScreenBufferPropertiesQNX)vk->vkGetDeviceProcAddr(
+ device, "vkGetScreenBufferPropertiesQNX");
+#endif
}
bool vulkan_dispatch_check_instance_VK_VERSION_1_0(const VulkanDispatch* vk)
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.h b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
index 6ee7c12..b2ecac9 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.h
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
@@ -488,6 +488,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -623,6 +625,9 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+ PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX;
+#endif
};
} // namespace vk
diff --git a/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp b/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
index 1929670..d7e7019 100644
--- a/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
@@ -140,6 +140,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -210,6 +212,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
uint32_t goldfish_vk_struct_type(const void* structExtension) {
const uint32_t asStructType = *(reinterpret_cast<const uint32_t*>(structExtension));
return asStructType;
@@ -623,6 +627,14 @@
return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
@@ -1201,6 +1213,14 @@
return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
diff --git a/host/vulkan/cereal/common/goldfish_vk_extension_structs.h b/host/vulkan/cereal/common/goldfish_vk_extension_structs.h
index 4bb7246..06ba3c0 100644
--- a/host/vulkan/cereal/common/goldfish_vk_extension_structs.h
+++ b/host/vulkan/cereal/common/goldfish_vk_extension_structs.h
@@ -154,6 +154,8 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -224,6 +226,8 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp b/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp
index 324f8a1..fbea4bc 100644
--- a/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp
@@ -3537,6 +3537,26 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toMap) {
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext) {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationDepthClipStateCreateInfoEXT* toMap) {
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext) {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -4099,6 +4119,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExtension_out) {
if (!structExtension_out) {
return;
@@ -4854,6 +4876,20 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_handlemap.h b/host/vulkan/cereal/common/goldfish_vk_handlemap.h
index 70665d8..75855a0 100644
--- a/host/vulkan/cereal/common/goldfish_vk_handlemap.h
+++ b/host/vulkan/cereal/common/goldfish_vk_handlemap.h
@@ -1302,6 +1302,14 @@
handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toMap);
+
+void handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationDepthClipStateCreateInfoEXT* toMap);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -1576,6 +1584,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toMap);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
index e811816..6cf617b 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
@@ -15432,6 +15432,84 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -17584,6 +17662,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
const void* structExtension) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -18429,6 +18509,22 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -19567,6 +19663,21 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
index cf170a1..84054ca 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
@@ -3171,6 +3171,24 @@
unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -3771,6 +3789,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
const char* api_opcode_to_string(const uint32_t opcode);
#define OP_vkFirst_old 20000
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
index 1f5e189..ffaef3d 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
@@ -11905,6 +11905,69 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void reservedunmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkBool32*)&forUnmarshaling->depthClipEnable, *ptr, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forUnmarshaling->flags, *ptr,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ *ptr += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
+ memcpy((VkBool32*)&forUnmarshaling->depthClipEnable, *ptr, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -13632,6 +13695,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
void* structExtension_out, uint8_t** ptr) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension_out);
@@ -14525,6 +14590,23 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ reservedunmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ reservedunmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out),
+ ptr);
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
reservedunmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
index d469929..377d139 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
@@ -1674,6 +1674,16 @@
reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void reservedunmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -2000,6 +2010,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling, uint8_t** ptr);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.cpp b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
index ff45e6b..8790c1c 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
@@ -7078,6 +7078,48 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
+#ifdef VK_EXT_depth_clip_enable
+void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -8164,6 +8206,8 @@
}
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
void* structExtension_out) {
if (!structExtension_out) {
@@ -8964,6 +9008,21 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -10054,6 +10113,21 @@
break;
}
#endif
+#ifdef VK_EXT_depth_clip_enable
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.h b/host/vulkan/cereal/common/goldfish_vk_transform.h
index d3a4e23..359fa4d 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.h
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.h
@@ -2782,6 +2782,22 @@
transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
#endif
+#ifdef VK_EXT_depth_clip_enable
+void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+
+void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform);
+
+#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -3308,6 +3324,8 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform);
#endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
} // namespace vk
} // namespace gfxstream
