VulkanCore

Structure containing callback functions for memory allocation.

Initializes a new instance of the structure.

The application-defined memory allocation function. The application-defined memory reallocation function. The application-defined memory free function The application-defined function that is called by the implementation when the implementation makes internal allocations. The application-defined function that is called by the implementation when the implementation frees internal allocations. The value to be interpreted by the implementation of the callbacks. When any of the callbacks in are called, the Vulkan implementation will pass this value as the first parameter to the callback. This value can vary each time an allocator is passed into a command, even when the same object takes an allocator in multiple commands.

The value to be interpreted by the implementation of the callbacks. When any of the callbacks in are called, the Vulkan implementation will pass this value as the first parameter to the callback. This value can vary each time an allocator is passed into a command, even when the same object takes an allocator in multiple commands.

The application-defined memory allocation function.

Gets the application-defined memory reallocation function.

Gets the application-defined memory free function.

The application-defined function that is called by the implementation when the implementation makes internal allocations. This value may be null.

The application-defined function that is called by the implementation when the implementation frees internal allocations. This value may be null.

Application-defined memory allocation function. If this function is unable to allocate the requested memory, it must return . If the allocation was successful, it must return a valid handle to memory allocation containing at least bytes, and with the pointer value being a multiple of . For example, this function (or ) could cause termination of running Vulkan instance(s) on a failed allocation for debugging purposes, either directly or indirectly. In these circumstances, it cannot be assumed that any part of any affected objects are going to operate correctly (even ), and the application must ensure it cleans up properly via other means (e.g. process termination). If this function returns , and if the implementation is unable to continue correct processing of the current command without the requested allocation, it must treat this as a run-time error, and generate at the appropriate time for the command in which the condition was detected. If the implementation is able to continue correct processing of the current command without the requested allocation, then it may do so, and must not generate as a result of this failed allocation.

Value specified for in the allocator specified by the application. Size in bytes of the requested allocation. Requested alignment of the allocation in bytes and must be a power of two. Value specifying the allocation scope of the lifetime of the allocation.

Application-defined memory reallocation function. Must return an allocation with enough space for bytes, and the contents of the original allocation from bytes zero to `min(original size, new size) - 1` must be preserved in the returned allocation. If is larger than the old size, the contents of the additional space are undefined. If satisfying these requirements involves creating a new allocation, then the old allocation should be freed. If is , then the function must behave equivalently to a call to with the same parameter values (without ). If is zero, then the function must behave equivalently to a call to with the same parameter value, and 'memory' equal to . If is not , the implementation must ensure that is equal to the used to originally allocate . If this function fails and is not the application must not free the old allocation. This function must follow the same rules for return values as .

Value specified for in the allocator specified by the application. Must be either or a pointer previously returned by or of the same allocator. Size in bytes of the requested allocation. Requested alignment of the allocation in bytes and must be a power of two. Value specifying the allocation scope of the lifetime of the allocation.

Application-defined memory free function. may be , which the callback must handle safely. If is not , it must be a handle to previously allocated by or . The application should free this memory.

Value specified for in the allocator specified by the application. Allocation to be freed.

Application-defined memory allocation notification function. This is a purely informational callback.

Value specified for in the allocator specified by the application. Size in bytes of the requested allocation. Requested type of an allocation. Value specifying the allocation scope of the lifetime of the allocation.

Application-defined memory free notification function.

Allocation scope.

Specifies that the allocation is scoped to the duration of the Vulkan command.

Specifies that the allocation is scoped to the lifetime of the Vulkan object that is being created or used.

Specifies that the allocation is scoped to the lifetime of a object.

Specifies that the allocation is scoped to the lifetime of the Vulkan device.

Specifies that the allocation is scoped to the lifetime of the Vulkan instance.

Allocation type.

Specifies that the allocation is intended for execution by the host.

Provides AMD specific extension methods for the class.

Perform an indirect draw with the draw count sourced from a buffer. Behaves similar to except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from located at and use this as the draw count.

The command buffer into which the command is recorded. The buffer containing draw parameters. The byte offset into where parameters begin. The buffer containing the draw count. The byte offset into where the draw count begins. Specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in and . The byte stride between successive sets of draw parameters.

Perform an indexed indirect draw with the draw count sourced from a buffer. Behaves similar to except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from located at and use this as the draw count.

Structure defining rasterization order for a graphics pipeline.

The type of this structure.

Is or a pointer to an extension-specific structure.

Specifies the primitive rasterization order to use.

Initializes a new instance of the structure.

Specifies the primitive rasterization order to use. Is or a pointer to an extension-specific structure.

Specify rasterization order for a graphics pipeline.

Specifies that the order of these operations for each primitive in a subpass must occur in primitive order.

Specifies that the order of these operations for each primitive in a subpass may not occur in primitive order.

Structure informing whether or not texture gather bias/LOD functionality is supported for a given image format and a given physical device.

The type of this structure.

Is .

Tells if the image format can be used with texture gather bias/LOD functions, as introduced by the "VK_AMD_texture_gather_bias_lod" extension. This field is set by the implementation. User-specified value is ignored.

Vulkan boolean type. true represents a boolean True (integer 1) value, and false a boolean False (integer 0) value.

Initializes a new instance of the struct.

Returns a string representing this instance.

The string representation.

Returns a boolean indicating whether the given is equal to this instance.

The to compare this instance to. true if the other is equal to this instance; false otherwise.

Returns a boolean indicating whether the given is equal to this instance.

The to compare against. true if the is equal to this instance; false otherwise.

Returns the hash code for this instance.

The hash code.

Returns a boolean indicating whether the two given booleans are equal.

The first boolean to compare. The second boolean to compare. true if the booleans are equal; false otherwise.

Returns a boolean indicating whether the two given booleans are not equal.

The first boolean to compare. The second boolean to compare. true if the booleans are not equal; false if they are equal.

Performs an implicit conversion from to .

The value to convert.

Performs an implicit conversion from to .

The value to convert.

Performs an implicit conversion from to .

The value to convert.

Performs an implicit conversion from to .

The value to convert.

Opaque handle to a buffer object. Buffers represent linear arrays of data which are used for various purposes by binding them to a graphics or compute pipeline via descriptor sets or via certain commands, or by directly specifying them as parameters to certain commands.

Gets the parent of the resource.

Bind device memory to a buffer object. Must not already be backed by a memory object. Must not have been created with any sparse memory binding flags.

The object describing the device memory to attach. The start offset of the region of memory which is to be bound to the buffer. The number of bytes returned in the member in memory, starting from bytes, will be bound to the specified buffer. Vulkan returns an error code.

Create a new buffer view object.

The structure containing parameters to be used to create the buffer. Controls host memory allocation. Vulkan returns an error code.

Returns the memory requirements for the buffer.

Memory requirements of the buffer object.

Destroy a buffer object.

Structure specifying the parameters of a newly created buffer object.

Is or a pointer to an extension-specific structure.

A bitmask specifying additional parameters of the buffer.

The size in bytes of the buffer to be created.

A bitmask specifying allowed usages of the buffer.

The sharing mode of the buffer when it will be accessed by multiple queue families.

A list of queue families that will access this buffer (ignored if is not ).

Initializes a new instance of the structure.

The size in bytes of the buffer to be created. The bitmask specifying allowed usages of the buffer. A bitmask specifying additional parameters of the buffer. The sharing mode of the buffer when it will be accessed by multiple queue families. A list of queue families that will access this buffer (ignored if is not ). Is or a pointer to an extension-specific structure.

Bitmask specifying allowed usages of a buffer.

Specifies that the buffer can be used as the source of a transfer command. (see the definition of ).

Specifies that the buffer can be used as the destination of a transfer command.

Specifies that the buffer can be used to create a suitable for occupying a slot of type .

Specifies that the buffer can be used in a suitable for occupying a slot either of type or .

Specifies that the buffer is suitable for passing as the buffer parameter to .

Specifies that the buffer is suitable for passing as an element of the pBuffers array to .

Specifies that the buffer is suitable for passing as the buffer parameter to , , or . It is also suitable for passing as the member, or or member.

Bitmask specifying additional parameters of a buffer.

No flags.

Specifies that the buffer will be backed using sparse memory binding.

Specifies that the buffer can be partially backed using sparse memory binding. Buffers created with this flag must also be created with the flag.

Specifies that the buffer will be backed using sparse memory binding with memory ranges that might also simultaneously be backing another buffer (or another portion of the same buffer). Buffers created with this flag must also be created with the flag.

Structure specifying memory requirements.

The size, in bytes, of the memory allocation required for the resource.

The alignment, in bytes, of the offset within the allocation required for the resource.

A bitmask that contains one bit set for every supported memory type for the resource. Bit `i` is set if and only if the memory type `i` in the structure for the physical device is supported for the resource.

Buffer and image sharing modes.

Specifies that access to any range or image subresource of the object will be exclusive to a single queue family at a time.

Specifies that concurrent access to any range or image subresource of the object from multiple queue families is supported.

Opaque handle to a buffer view object. A buffer view represents a contiguous range of a buffer and a specific format to be used to interpret the data. Buffer views are used to enable shaders to access buffer contents interpreted as formatted data.

Gets the parent of the resource.

Destroy a buffer view object.

Structure specifying parameters of a newly created buffer view.

The format of the data elements in the buffer.

An offset in bytes from the base address of the buffer. Accesses to the buffer view from shaders use addressing that is relative to this starting offset. Must be less than the size of buffer. Must be a multiple of .

A size in bytes of the buffer view. If range is equal to , the range from offset to the end of the buffer is used. If is used and the remaining size of the buffer is not a multiple of the element size of format, then the nearest smaller multiple is used.

Initializes a new instance of the structure.

The format of the data elements in the buffer. An offset in bytes from the base address of the buffer. Accesses to the buffer view from shaders use addressing that is relative to this starting offset. Must be less than the size of buffer. Must be a multiple of . A size in bytes of the buffer view. If range is equal to , the range from offset to the end of the buffer is used. If is used and the remaining size of the buffer is not a multiple of the element size of format, then the nearest smaller multiple is used.

Structure specifying color value when the format of the image or attachment is one of the formats other than signed integer or unsigned integer. Floating point values are automatically converted to the format of the image.

Gets a with all of its components set to zero.

The red component of the color.

The green component of the color.

The blue component of the color.

The alpha component of the color.

Initializes a new instance of the structure.

The red component. The green component. The blue component. The alpha component.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Structure specifying color value when the format of the image or attachment is signed integer. Signed integer values are converted to the format of the image by casting to the smaller type (with negative 32-bit values mapping to negative values in the smaller type). If the integer value is not representable in the target type (e.g. would overflow in conversion to that type), the value is undefined.

Gets a with all of its components set to zero.

The red component of the color.

The green component of the color.

The blue component of the color.

The alpha component of the color.

Initializes a new instance of the structure.

The red component. The green component. The blue component. The alpha component.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Structure specifying color value when the format of the image or attachment is unsigned integer. Unsigned integer values are converted to the format of the image by casting to the integer type with fewer bits.

Gets a with all of its components set to zero.

The red component of the color.

The green component of the color.

The blue component of the color.

The alpha component of the color.

Initializes a new instance of the structure.

The red component. The green component. The blue component. The alpha component.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Opaque handle to a command buffer object. Command buffers are objects used to record commands which can be subsequently submitted to a device queue for execution. There are two levels of command buffers - primary command buffers, which can execute secondary command buffers, and which are submitted to queues, and secondary command buffers, which can be executed by primary command buffers, and which are not directly submitted to queues.

Gets the parent of the resource.

Start recording the command buffer.

Defines additional information about how the command buffer begins recording. Vulkan returns an error code.

Finish recording the command buffer.

Vulkan returns an error code.

Reset a command buffer to the initial state.

A bitmask controlling the reset operation. If flags includes , then most or all memory resources currently owned by the command buffer should be returned to the parent command pool. If this flag is not set, then the command buffer may hold onto memory resources and reuse them when recording commands. Vulkan returns an error code.

Bind a pipeline object to a command buffer.

Specifies whether pipeline will be bound as a compute or graphics pipeline. There are separate bind points for each of graphics and compute, so binding one does not disturb the other. The pipeline to be bound.

Set the viewport on a command buffer. If the bound pipeline state object was not created with the dynamic state enabled, viewport transformation parameters are specified using the member in the pipeline state object. If the pipeline state object was created with the dynamic state enabled, the viewport transformation parameters are dynamically set and changed with this command.

Specifies viewport parameters.

The index of the first viewport whose parameters are updated by the command. The index of the first viewport whose parameters are updated by the command. Structures specifying viewport parameters.

Set the dynamic scissor rectangles on a command buffer. The scissor test determines if a fragment’s framebuffer coordinates (xf,yf) lie within the scissor rectangle corresponding to the viewport index used by the primitive that generated the fragment. If the pipeline state object is created without enabled then the scissor rectangles are set by the state of the pipeline state object. Otherwise, to dynamically set the scissor rectangles call this command.

Defines scissor rectangle.

The index of the first scissor whose state is updated by the command. The number of scissors whose rectangles are updated by the command. Structures defining scissor rectangles.

Set the dynamic line width state. The line width is set by the property in the currently active pipeline if the pipeline was not created with enabled. Otherwise, the line width is set by calling this command.

The width of rasterized line segments.

Set the depth bias dynamic state. The depth values of all fragments generated by the rasterization of a polygon can be offset by a single value that is computed for that polygon. This behavior is controlled by the , members, or by the corresponding parameters to the this command if depth bias state is dynamic.

A scalar factor controlling the constant depth value added to each fragment. The maximum (or minimum) depth bias of a fragment. A scalar factor applied to a fragment’s slope in depth bias calculations.

Set the values of blend constants.

The R, G, B, and A components of the blend constant color used in blending, depending on the blend factor.

Set the depth bounds test values for a command buffer. The depth bounds test conditionally disables coverage of a sample based on the outcome of a comparison between the value za in the depth attachment at location (xf,yf) (for the appropriate sample) and a range of values. The test is enabled or disabled by the member. If the pipeline state object is created without the dynamic state enabled then the range of values used in the depth bounds test are defined by the and members. Otherwise, to dynamically set the depth bounds range values call this command.

The lower bound of the range of depth values used in the depth bounds test. The upper bound of the range.

Set the stencil compare mask dynamic state. If the pipeline state object is created with the dynamic state enabled, then to dynamically set the stencil compare mask call this command.

A bitmask specifying the set of stencil state for which to update the compare mask. The new value to use as the stencil compare mask.

Set the stencil write mask dynamic state. If the pipeline state object is created with the dynamic state enabled, then to dynamically set the stencil write mask call this command.

Specifies the set of stencil state for which to update the write mask. The new value to use as the stencil write mask.

Set the stencil reference dynamic state. If the pipeline state object is created with the dynamic state enabled, then to dynamically set the stencil reference value call this command.

Specifies the set of stencil state for which to update the reference value. the new value to use as the stencil reference value.

Binds descriptor set to a command buffer.

Indicates whether the descriptors will be used by graphics pipelines or compute pipelines. There is a separate set of bind points for each of graphics and compute, so binding one does not disturb the other. A object used to program the bindings. Handle to a object describing the descriptor set to write to. Value specifying dynamic offset.

Binds descriptor sets to a command buffer.

Indicates whether the descriptors will be used by graphics pipelines or compute pipelines. There is a separate set of bind points for each of graphics and compute, so binding one does not disturb the other. A object used to program the bindings. The set number of the first descriptor set to be bound. Handles to objects describing the descriptor sets to write to. Values specifying dynamic offsets.

Bind an index buffer to a command buffer.

The buffer being bound. The starting offset in bytes within buffer used in index buffer address calculations. Selects whether indices are treated as 16 bits or 32 bits.

Bind vertex buffer to a command buffer.

The handle. The offsets.

Bind vertex buffers to a command buffer.

The index of the first vertex input binding whose state is updated by the command. The number of vertex input bindings whose state is updated by the command. An array of handles. An array of offsets.

Draw primitives. When the command is executed, primitives are assembled using the current primitive topology and consecutive vertex indices with the first vertex index value equal to . The primitives are drawn times with instance index starting with and increasing sequentially for each instance. The assembled primitives execute the currently bound graphics pipeline.

The number of vertices to draw. The number of instances to draw. The index of the first vertex to draw. The instance id of the first instance to draw.

Issue an indexed draw into a command buffer. When the command is executed, primitives are assembled using the current primitive topology and vertices whose indices are retrieved from the index buffer. The index buffer is treated as an array of tightly packed unsigned integers of size defined by the index type parameter with which the buffer was bound.

The number of vertices to draw. The number of instances to draw. The base index within the index buffer. The value added to the vertex index before indexing into the vertex buffer. The instance id of the first instance to draw.

Issue an indirect draw into a command buffer. Behaves similarly to except that the parameters are read by the device from a buffer during execution. draws are executed by the command, with parameters taken from buffer starting at and increasing by bytes for each successive draw. If is less than or equal to one, is ignored.

The buffer containing draw parameters. The byte offset into buffer where parameters begin. The number of draws to execute, and can be zero. The byte stride between successive sets of draw parameters.

Perform an indexed indirect draw. Behaves similarly to except that the parameters are read by the device from a buffer during execution. draws are executed by the command, with parameters taken from buffer starting at and increasing by bytes for each successive draw. If is less than or equal to one, is ignored.

The buffer containing draw parameters. The byte offset into buffer where parameters begin. The number of draws to execute, and can be zero. The byte stride between successive sets of draw parameters.

Dispatch compute work items. When the command is executed, a global workgroup consisting of x × y × z local workgroups is assembled.

The number of local workgroups to dispatch in the X dimension. The number of local workgroups to dispatch in the Y dimension. The number of local workgroups to dispatch in the Z dimension.

Dispatch compute work items using indirect parameters. Behaves similarly to except that the parameters are read by the device from a buffer during execution.

The buffer containing dispatch parameters. The byte offset into buffer where parameters begin.

Copy data between buffer regions. Each region in is copied from the source buffer to the same region of the destination buffer. and can be the same buffer or alias the same memory, but the result is undefined if the copy regions overlap in memory.

The source buffer. The destination buffer. Structures specifying the regions to copy.

Copy data between images.

The source image. The current layout of the source image subresource. The destination image. The current layout of the destination image subresource. Structures specifying the regions to copy.

Copy regions of an image, potentially performing format conversion, arbitrary scaling, and filtering. Must not be used for multisampled source or destination images. Use for this purpose.

The source image. The layout of the source image subresources for the blit. The source image. The layout of the destination image subresources for the blit. Structures specifying the regions to blit. Specifies the filter to apply if the blits require scaling.

Copy data from a buffer into an image. Each region in is copied from the specified region of the source buffer to the specified region of the destination image.

The source buffer. The destination image. The layout of the destination image subresources for the copy. Structures specifying the regions to copy.

Copy image data into a buffer. Each region in is copied from the specified region of the source image to the specified region of the destination buffer.

The source image. The layout of the source image subresources for the copy. The destination buffer. Structures specifying the regions to copy.

Update a buffer's contents from host memory. must be less than or equal to 65536 bytes. For larger updates, applications can use buffer to buffer copies. Is only allowed outside of a render pass. This command is treated as "transfer" operation, for the purposes of synchronization barriers. The must be specified in usage of in order for the buffer to be compatible with .

A handle to the buffer to be updated. The byte offset into the buffer to start updating, and must be a multiple of 4. The number of bytes to update, and must be a multiple of 4. A pointer to the source data for the buffer update, and must be at least bytes in size.

Fill a region of a buffer with a fixed value. Is treated as "transfer" operation for the purposes of synchronization barriers. The must be specified in usage of in order for the buffer to be compatible with .

The buffer to be filled. The byte offset into the buffer at which to start filling, and must be a multiple of 4. the number of bytes to fill, and must be either a multiple of 4, or to fill the range from offset to the end of the buffer. If is used and the remaining size of the buffer is not a multiple of 4, then the nearest smaller multiple is used. The 4-byte word written repeatedly to the buffer to fill size bytes of data. The data word is written to memory according to the host endianness.

Clear regions of a color image. Each specified range in is cleared to the value specified by .

The image to be cleared. Specifies the current layout of the image subresource ranges to be cleared, and must be or . Contains the values the image subresource ranges will be cleared to. Structures that describe a range of mipmap levels, array layers, and aspects to be cleared. The aspect mask of all image subresource ranges must only include .

Fill regions of a combined depth/stencil image.

The image to be cleared. Specifies the current layout of the image subresource ranges to be cleared, and must be or . Structure that contains the values the depth and stencil image subresource ranges will be cleared to. Structures that describe a range of mipmap levels, array layers, and aspects to be cleared. The aspect mask of each image subresource range in can include if the image format has a depth component, and if the image format has a stencil component.

Clear regions within currently bound framebuffer attachments. Can clear multiple regions of each attachment used in the current subpass of a render pass instance. This command must be called only inside a render pass instance, and implicitly selects the images to clear based on the current framebuffer attachments and the command parameters.

Structures defining the attachments to clear and the clear values to use. Structures defining regions within each selected attachment to clear.

Resolve regions of an image. During the resolve the samples corresponding to each pixel location in the source are converted to a single sample before being written to the destination. If the source formats are floating-point or normalized types, the sample values for each pixel are resolved in an implementation-dependent manner. If the source formats are integer types, a single sample’s value is selected for each pixel.

The source image. The layout of the source image subresources for the resolve. The destination image. The layout of the destination image subresources for the resolve. Structures specifying the regions to resolve.

Set an event object to signaled state. When is submitted to a queue, it defines an execution dependency on commands that were submitted before it, and defines an event signal operation which sets the event to the signaled state.

The event that will be signaled. Specifies the source stage mask used to determine when the is signaled.

Reset an event object to non-signaled state. When is submitted to a queue, it defines an execution dependency on commands that were submitted before it, and defines an event unsignal operation which resets the event to the unsignaled state.

The event that will be unsignaled. Specifies the source stage mask used to determine when the is unsignaled.

Wait for one or more events and insert a set of memory. When is submitted to a queue, it defines a memory dependency between prior event signal operations, and subsequent commands.

Event object handles to wait on. The source stage mask. The destination stage mask. An array of structures. An array of structures. An array of structures.

Wait for an event and insert a set of memory. When is submitted to a queue, it defines a memory dependency between prior event signal operations, and subsequent commands.

Event object handle to wait on. The source stage mask. The destination stage mask. An array of structures. An array of structures. An array of structures.

Insert a memory dependency. When the command is submitted to a queue, it defines a memory dependency between commands that were submitted before it, and those submitted after it.

Defines a source stage mask. Defines a destination stage mask. a bitmask of . An array of structures. An array of structures. An array of structures.

Begin a query.

The query pool that will manage the results of the query. The query index within the query pool that will contain the results. A bitmask indicating constraints on the types of queries that can be performed.

Ends a query. As queries operate asynchronously, ending a query does not immediately set the query’s status to available. A query is considered finished when the final results of the query are ready to be retrieved by and , and this is when the query’s status is set to available. Once a query is ended the query must finish in finite time, unless the state of the query is changed using other commands, e.g. by issuing a reset of the query.

The query pool that is managing the results of the query. The query index within the query pool where the result is stored.

Reset queries in a query pool. When executed on a queue, this command sets the status of query indices [firstQuery, firstQuery + queryCount - 1] to unavailable.

The handle of the query pool managing the queries being reset. The initial query index to reset. The number of queries to reset.

Write a device timestamp into a query object. Latches the value of the timer when all previous commands have completed executing as far as the specified pipeline stage, and writes the timestamp value to memory. When the timestamp value is written, the availability status of the query is set to available.

Specifies a stage of the pipeline. The query pool that will manage the timestamp. The query within the query pool that will contain the timestamp.

Copy the results of queries in a query pool to a buffer object. Is guaranteed to see the effect of previous uses of in the same queue, without any additional synchronization. Thus, the results will always reflect the most recent use of the query.

The query pool managing the queries containing the desired results. The initial query index. The number of queries. and together define a range of queries. Buffer object that will receive the results of the copy command. An offset into . The stride in bytes between results for individual queries within . The required size of the backing memory for is determined as described above for . A bitmask specifying how and when results are returned.

Update the values of push constants.

The pipeline layout used to program the push constant updates. A bitmask specifying the shader stages that will use the push constants in the updated range. Must match exactly the shader stages used in for the range specified by and . The start offset of the push constant range to update, in units of bytes. Must be a multiple of 4. Must be less than . The size of the push constant range to update, in units of bytes. Must be a multiple of 4. Must be less than or equal to minus . An array of bytes containing the new push constant values.

Begin a new render pass. After beginning a render pass instance, the command buffer is ready to record the commands for the first subpass of that render pass.

Indicates the render pass to begin an instance of, and the framebuffer the instance uses. Specifies how the commands in the first subpass will be provided.

Transition to the next subpass of a render pass. The subpass index for a render pass begins at zero when is recorded, and increments each time is recorded. Moving to the next subpass automatically performs any multisample resolve operations in the subpass being ended. End-of-subpass multisample resolves are treated as color attachment writes for the purposes of synchronization. That is, they are considered to execute in the pipeline stage and their writes are synchronized with . Synchronization between rendering within a subpass and any resolve operations at the end of the subpass occurs automatically, without need for explicit dependencies or pipeline barriers. However, if the resolve attachment is also used in a different subpass, an explicit dependency is needed. After transitioning to the next subpass, the application can record the commands for that subpass.

Specifies how the commands in the next subpass will be provided, in the same fashion as the corresponding parameter of .

End the current render pass. Ending a render pass instance performs any multisample resolve operations on the final subpass.

Execute a secondary command buffer from a primary command buffer. A secondary command buffer must not be directly submitted to a queue. Instead, secondary command buffers are recorded to execute as part of a primary command buffer with this command.

Secondary command buffer handle, which is recorded to execute in the primary command buffer.

Secondary command buffer handles, which are recorded to execute in the primary command buffer in the order they are listed in the array.

Free command buffer.

Structure specifying the allocation parameters for command buffer object.

Specifies the command buffer level.

The number of command buffers to allocate from the pool.

Inititializes a new instance of the structure.

Specifies the command buffer level. The number of command buffers to allocate from the pool.

Enumerant specifying a command buffer level.

Specifies a primary command buffer.

Specifies a secondary command buffer.

Structure specifying a command buffer begin operation.

A bitmask specifying usage behavior for the command buffer.

Structure, which is used if command buffer is a secondary command buffer. If it is a primary command buffer, then this value is ignored.

Initializes a new instance of the structure.

A bitmask specifying usage behavior for the command buffer. Structure, which is used if command buffer is a secondary command buffer. If it is a primary command buffer, then this value is ignored.

Bitmask specifying usage behavior for command buffer.

No flags.

Specifies that each recording of the command buffer will only be submitted once, and the command buffer will be reset and recorded again between each submission.

Specifies that a secondary command buffer is considered to be entirely inside a render pass. If this is a primary command buffer, then this bit is ignored.

Specifies that a command buffer can be resubmitted to a queue while it is in the pending State, and recorded into multiple primary command buffers.

Structure specifying command buffer inheritance info.

A object defining which render passes the will be compatible with and can be executed within. If the will not be executed within a render pass instance, is ignored.

The index of the subpass within the render pass instance that the will be executed within. If the will not be executed within a render pass instance, subpass is ignored.

Optionally refers to the object that the will be rendering to if it is executed within a render pass instance. It can be 0 if the framebuffer is not known, or if the will not be executed within a render pass instance. Specifying the exact framebuffer that the secondary command buffer will be executed with may result in better performance at command buffer execution time.

Indicates whether the command buffer can be executed while an occlusion query is active in the primary command buffer. If this is true, then this command buffer can be executed whether the primary command buffer has an occlusion query active or not. If this is false, then the primary command buffer must not have an occlusion query active.

Indicates the query flags that can be used by an active occlusion query in the primary command buffer when this secondary command buffer is executed. If this value includes the bit, then the active query can return boolean results or actual sample counts. If this bit is not set, then the active query must not use the bit.

Specifies the set of pipeline statistics that can be counted by an active query in the primary command buffer when this secondary command buffer is executed. If this value includes a given bit, then this command buffer can be executed whether the primary command buffer has a pipeline statistics query active that includes this bit or not. If this value excludes a given bit, then the active pipeline statistics query must not be from a query pool that counts that statistic.

Bitmask specifying constraints on a query.

No flags.

Specifies the precision of occlusion queries.

Bitmask specifying queried pipeline statistics.

No flags.

Specifies that queries managed by the pool will count the number of vertices processed by the input assembly stage. Vertices corresponding to incomplete primitives may contribute to the count.

Specifies that queries managed by the pool will count the number of primitives processed by the input assembly stage. If primitive restart is enabled, restarting the primitive topology has no effect on the count. Incomplete primitives may be counted.

Specifies that queries managed by the pool will count the number of vertex shader invocations. This counter's value is incremented each time a vertex shader is invoked.

Specifies that queries managed by the pool will count the number of geometry shader invocations. This counter's value is incremented each time a geometry shader is invoked. In the case of instanced geometry shaders, the geometry shader invocations count is incremented for each separate instanced invocation.

Specifies that queries managed by the pool will count the number of primitives generated by geometry shader invocations. The counter's value is incremented each time the geometry shader emits a primitive. Restarting primitive topology using the SPIR-V instructions OpEndPrimitive or OpEndStreamPrimitive has no effect on the geometry shader output primitives count.

Specifies that queries managed by the pool will count the number of primitives processed by the primitive clipping stage of the pipeline. The counter's value is incremented each time a primitive reaches the primitive clipping stage.

Specifies that queries managed by the pool will count the number of primitives output by the primitive clipping stage of the pipeline. The counter's value is incremented each time a primitive passes the primitive clipping stage. The actual number of primitives output by the primitive clipping stage for a particular input primitive is implementation-dependent but must satisfy the following conditions: ** If at least one vertex of the input primitive lies inside the clipping volume, the counter is incremented by one or more. ** Otherwise, the counter is incremented by zero or more.

Specifies that queries managed by the pool will count the number of fragment shader invocations. The counter's value is incremented each time the fragment shader is invoked.

Specifies that queries managed by the pool will count the number of patches processed by the tessellation control shader. The counter's value is incremented once for each patch for which a tessellation control shader is invoked.

Specifies that queries managed by the pool will count the number of invocations of the tessellation evaluation shader. The counter's value is incremented each time the tessellation evaluation shader is invoked.

Specifies that queries managed by the pool will count the number of compute shader invocations. The counter's value is incremented every time the compute shader is invoked. Implementations may skip the execution of certain compute shader invocations or execute additional compute shader invocations for implementation-dependent reasons as long as the results of rendering otherwise remain unchanged.

Bitmask controlling behavior of a command buffer reset.

No flags.

Specifies that most or all memory resources currently owned by the command buffer should be returned to the parent command pool. If this flag is not set, then the command buffer may hold onto memory resources and reuse them when recording commands. Command buffer is moved to the initial state.

Type of index buffer indices.

Specifies that indices are 16-bit unsigned integer values.

Specifies that indices are 32-bit unsigned integer values.

Bitmask specifying sets of stencil state for which to update the compare mask.

Specifies that only the front set of stencil state is updated.

Specifies that only the back set of stencil state is updated.

Is the combination of and , and specifies that both sets of stencil state are updated.

Structure specifying a buffer copy operation.

The starting offset in bytes from the start of source buffer.

The starting offset in bytes from the start of destination buffer.

The number of bytes to copy.

Initializes a new instance of the structure.

The starting offset in bytes from the start of source buffer. The starting offset in bytes from the start of destination buffer. The number of bytes to copy.

Structure specifying an image copy operation.

Specifies the image subresource of the image used for the source image data.

Selects the initial x, y, and z offsets in texels of the sub-region of the source image data.

Specifies the image subresource of the image used for the destination image data.

Selects the initial x, y, and z offsets in texels of the sub-region of the source image data.

The size in texels of the source image to copy in width, height and depth.

Structure specifying a image subresource layers.

A combination of selecting the color, depth and/or stencil aspects to be copied. Must not contain .

The mipmap level to copy from. Must be less than the specified when the image was created.

The starting layer. Must be less than or equal to the arrayLayers specified in when the image was created.

The number of layers to copy.

Initializes a new instance of the structure.

A combination of selecting the color, depth and/or stencil aspects to be copied. The mipmap level to copy from. The starting layer. The number of layers to copy.

Structure specifying an image blit operation.

The subresource to blit from.

Specifies the bounds of the first source region within .

Specifies the bounds of the second source region within .

The subresource to blit into.

Specifies the bounds of the first destination region within .

Specifies the bounds of the second destination region within .

Structure specifying a buffer image copy operation.

the offset in bytes from the start of the buffer object where the image data is copied from or to. Must be a multiple of 4.

Specifies the data in buffer memory as a subregion of a larger two- or three-dimensional image, and control the addressing calculations of data in buffer memory. If this value is zero, that aspect of the buffer memory is considered to be tightly packed according to the . Must be 0, or greater than or equal to the width member. of imageExtent.

Used to specify the specific image subresources of the image used for the source or destination image data.

Selects the initial x, y, z offsets in texels of the sub-region of the source or destination image data.

The size in texels of the image to copy in width, height and depth.

Structure specifying a clear color value.

Are the color clear values when the format of the image or attachment is one of the formats other than signed integer or unsigned integer. Floating point values are automatically converted to the format of the image, with the clear value being treated as linear if the image is sRGB.

Are the color clear values when the format of the image or attachment is signed integer. Signed integer values are converted to the format of the image by casting to the smaller type (with negative 32-bit values mapping to negative values in the smaller type). If the integer clear value is not representable in the target type (e.g. would overflow in conversion to that type), the clear value is undefined.

Are the color clear values when the format of the image or attachment is unsigned integer. Unsigned integer values are converted to the format of the image by casting to the integer type with fewer bits.

Initializes a new instance of the structure.

Structure specifying a clear depth stencil value.

The clear value for the depth aspect of the depth/stencil attachment. It is a floating-point value which is automatically converted to the attachment’s format. Must be between 0.0 and 1.0, inclusive.

The clear value for the stencil aspect of the depth/stencil attachment. It is a 32-bit integer value which is converted to the attachment's format by taking the appropriate number of LSBs.

Initializes a new instance of the structure.

The clear value for the depth aspect of the depth/stencil attachment. It is a floating-point value which is automatically converted to the attachment’s format. The clear value for the stencil aspect of the depth/stencil attachment. It is a 32-bit integer value which is converted to the attachment's format by taking the appropriate number of LSBs.

Structure specifying a clear value.

Specifies the color image clear values to use when clearing a color image or attachment.

Specifies the depth and stencil clear values to use when clearing a depth/stencil image or attachment.

Initializes a new instance of the structure.

Specifies the color image clear values to use when clearing a color image or attachment.

Initializes a new instance of the structure.

Specifies the depth and stencil clear values to use when clearing a depth/stencil image or attachment.

Implicitly converts an instance of to an instance of .

Instance to convert.

Implicitly converts an instance of to an instance of .

Instance to convert.

Structure specifying a clear attachment.

A mask selecting the color, depth and/or stencil aspects of the attachment to be cleared. can include for color attachments, for depth/stencil attachments with a depth component, and for depth/stencil attachments with a stencil component. If the subpass's depth/stencil attachment is , then the clear has no effect. Must not include .

Is only meaningful if is set in , in which case it is an index to the array in the of the current subpass which selects the color attachment to clear. If is then the clear has no effect.

The color or depth/stencil value to clear the attachment to.

Structure specifying an image resolve operation.

Specifies the image subresource of the source image data. Resolve of depth/stencil image is not supported.

Selects the initial x, y, and z offsets in texels of the sub-region of the source image data.

Specifies the image subresource of the destination image data. Resolve of depth/stencil image is not supported.

Selects the initial x, y, and z offsets in texels of the sub-region of the destination image data.

The size in texels of the source image to resolve in width, height and depth.

Structure specifying a global memory barrier.

Specifies a source access mask.

Specifies a destination access mask.

Initializes a new instance of the structure.

Specifies a source access mask. Specifies a destination access mask.

Structure specifying a buffer memory barrier.

Specifies a source access mask.

Specifies a destination access mask.

The source queue family for a queue family ownership transfer.

The destination queue family for a queue family ownership transfer.

A handle to the buffer whose backing memory is affected by the barrier.

An offset in bytes into the backing memory for buffer; this is relative to the base offset as bound to the buffer.

A size in bytes of the affected area of backing memory for buffer, or to use the range from offset to the end of the buffer.

Initializes a new instance of the structure.

A handle to the buffer whose backing memory is affected by the barrier. Specifies a source access mask. Specifies a destination access mask. An offset in bytes into the backing memory for buffer; this is relative to the base offset as bound to the buffer. A size in bytes of the affected area of backing memory for buffer, or to use the range from offset to the end of the buffer.

Initializes a new instance of the structure.

A handle to the buffer whose backing memory is affected by the barrier. Specifies a source access mask. Specifies a destination access mask. The source queue family for a queue family ownership transfer. The destination queue family for a queue family ownership transfer. An offset in bytes into the backing memory for buffer; this is relative to the base offset as bound to the buffer. A size in bytes of the affected area of backing memory for buffer, or to use the range from offset to the end of the buffer.

Structure specifying the parameters of an image memory barrier.

Specifies a source access mask.

Specifies a destination access mask.

The old layout in an image layout transition. Must be or the current layout of the image subresources affected by the barrier.

The new layout in an image layout transition. Must not be or

The source queue family for a queue family ownership transfer.

The destination queue family for a queue family ownership transfer.

A handle to the affected by this barrier.

Describes an area of the backing memory for image, as well as the set of image subresources whose image layouts are modified.

Initializes a new instance of the structure.

A handle to the affected by this barrier. Describes an area of the backing memory for image, as well as the set of image subresources whose image layouts are modified. Specifies a source access mask. Specifies a destination access mask. The old layout in an image layout transition. The new layout in an image layout transition. The source queue family for a queue family ownership transfer. The destination queue family for a queue family ownership transfer.

Bitmask specifying memory access types that will participate in a memory dependency.

No flags.

Specifies read access to an indirect command structure read as part of an indirect drawing or dispatch command.

Specifies read access to an index buffer as part of an indexed drawing command, bound by .

Specifies read access to a vertex buffer as part of a drawing command, bound by .

Specifies read access to a uniform buffer.

Specifies read access to an input attachment within a renderpass during fragment shading.

Specifies read access to a storage buffer, uniform texel buffer, storage texel buffer, sampled image or storage image.

Specifies write access to a storage buffer, storage texel buffer or storage image.

Specifies read access to a color attachment, such as via blending, logic operations or via certain subpass load operations.

Specifies write access to a color or resolve attachment during a render pass or via certain subpass load and store operations.

Specifies read access to a depth/stencil attachment via depth or stencil operations or via certain subpass load operations.

Specifies write access to a depth/stencil attachment via depth or stencil operations or via certain subpass load and store operations.

Specifies read access to an image or buffer in a copy operation.

Specifies write access to an image or buffer in a clear or copy operation.

Specifies read access by a host operation. Accesses of this type are not performed through a resource, but directly on memory.

Specifies write access by a host operation. Accesses of this type are not performed through a resource, but directly on memory.

Specifies read access via non-specific entities. These entities include the Vulkan device and host, but may also include entities external to the Vulkan device or otherwise not part of the core Vulkan pipeline. When included in a destination access mask, makes all available writes visible to all future read accesses on entities known to the Vulkan device.

Specifies write access via non-specific entities. These entities include the Vulkan device and host, but may also include entities external to the Vulkan device or otherwise not part of the core Vulkan pipeline. When included in a source access mask, all writes that are performed by entities known to the Vulkan device are made available. When included in a destination access mask, makes all available writes visible to all future write accesses on entities known to the Vulkan device.

Specifies reads from inputs to .

Specifies writes to the target command buffer in .

Is similar to , but also includes advanced blend operations.

Structure specifying render pass begin info.

The to begin an instance of.

The containing the attachments that are used with the render pass.

The render area that is affected by the render pass instance. The effects of attachment load, store and multisample resolve operations are restricted to the pixels whose x and y coordinates fall within the render area on all attachments. The render area extends to all layers of framebuffer. The application must ensure (using scissor if necessary) that all rendering is contained within the render area, otherwise the pixels outside of the render area become undefined and shader side effects may occur for fragments outside the render area. The render area must be contained within the framebuffer dimensions.

An array of structures that contains clear values for each attachment, if the attachment uses a value of or if the attachment has a depth/stencil format and uses a value of . The array is indexed by attachment number. Only elements corresponding to cleared attachments are used. Other elements of are ignored.

Initializes a new instance of the structure.

The containing the attachments that are used with the render pass. The render area that is affected by the render pass instance. An array of structures that contains clear values for each attachment, if the attachment uses a value of or if the attachment has a depth/stencil format and uses a value of . The array is indexed by attachment number. Only elements corresponding to cleared attachments are used. Other elements of are ignored.

Initializes a new instance of the structure.

The containing the attachments that are used with the render pass. The to use. The render area that is affected by the render pass instance. An array of structures that contains clear values for each attachment, if the attachment uses a value of or if the attachment has a depth/stencil format and uses a value of . The array is indexed by attachment number. Only elements corresponding to cleared attachments are used. Other elements of are ignored.

Specify how commands in the first subpass of a render pass are provided.

Specifies that the contents of the subpass will be recorded inline in the primary command buffer, and secondary command buffers must not be executed within the subpass.

Specifies that the contents are recorded in secondary command buffers that will be called from the primary command buffer, and is the only valid command on the command buffer until or .

Bitmask specifying pipeline stages.

Specifies the stage of the pipeline where any commands are initially received by the queue.

Specifies the stage of the pipeline where Draw/DispatchIndirect data structures are consumed. This stage also includes reading commands written by .

Specifies the stage of the pipeline where vertex and index buffers are consumed.

Specifies the vertex shader stage.

Specifies the tessellation control shader stage.

Specifies the tessellation evaluation shader stage.

Specifies the geometry shader stage.

Specifies the fragment shader stage.

Specifies the stage of the pipeline where early fragment tests (depth and stencil tests before fragment shading) are performed. This stage also includes subpass load operations for framebuffer attachments with a depth/stencil format.

Specifies that the stage of the pipeline where late fragment tests (depth and stencil tests after fragment shading) are performed. This stage also includes subpass store operations for framebuffer attachments with a depth/stencil format.

Specifies that the stage of the pipeline after blending where the final color values are output from the pipeline. This stage also includes subpass load and store operations and multisample resolve operations for framebuffer attachments with a color format.

Specifies the execution of a compute shader.

Transfer/copy operations.

Specifies the final stage in the pipeline where operations generated by all commands complete execution.

Specifies a pseudo-stage indicating execution on the host of reads/writes of device memory. This stage is not invoked by any commands recorded in a command buffer.

Specifies the execution of all graphics pipeline stages, and is equivalent to the logical OR of: , , , , , , , , , , , .

Equivalent to the logical OR of every other pipeline stage flag that is supported on the queue it is used with.

Specifies the stage of the pipeline where device-side generation of commands via is handled.

Structure specifying a clear rectangle.

The two-dimensional region to be cleared.

The first layer to be cleared.

The number of layers to clear.

Initializes a new instance of the structure.

The two-dimensional region to be cleared. The first layer to be cleared. The number of layers to clear.

Opaque handle to a command pool object. Command pools are opaque objects that command buffer memory is allocated from, and which allow the implementation to amortize the cost of resource creation across multiple command buffers. Command pools are application-synchronized, meaning that a command pool must not be used concurrently in multiple threads. That includes use via recording commands on any command buffers allocated from the pool, as well as operations that allocate, free, and reset command buffers or the pool itself.

Gets the parent of the resource.

Reset a command pool.

Contains additional flags controlling the behavior of the reset. If flags includes , resetting a command pool recycles all of the resources from the command pool back to the system. Vulkan returns an error code.

Allocate command buffers from an existing command pool.

The structure describing parameters of the allocation. The resulting command buffer objects returned. Each allocated command buffer begins in the initial state. Vulkan returns an error code.

Free command buffers.

Command buffers to free.

Destroy a command pool object. When a pool is destroyed, all command buffers allocated from the pool are implicitly freed and become invalid. Command buffers allocated from a given pool do not need to be freed before destroying that command pool.

Structure specifying parameters of a newly created command pool.

A bitmask indicating usage behavior for the pool and command buffers allocated from it.

Designates a queue family. All command buffers allocated from this command pool must be submitted on queues from the same queue family.

Initializes a new instance of the structure.

Designates a queue family. All command buffers allocated from this command pool must be submitted on queues from the same queue family. A bitmask indicating usage behavior for the pool and command buffers allocated from it.

Bitmask specifying usage behavior for a command pool.

No flags.

Indicates that command buffers allocated from the pool will be short-lived, meaning that they will be reset or freed in a relatively short timeframe. This flag may be used by the implementation to control memory allocation behavior within the pool.

Allows any command buffer allocated from a pool to be individually reset to the initial state either by calling , or via the implicit reset when calling . If this flag is not set on a pool, then must not be called for any command buffer allocated from that pool.

Bitmask controlling behavior of a command pool reset.

No flags.

Specifies that resetting a command pool recycles all of the resources from the command pool back to the system.

Provides Vulkan specific constants for special values, layer names and extension names.

The maximum number of unique memory heaps, each of which supporting 1 or more memory types.

Provides name constants for common Vulkan instance extensions.

The "VK_KHR_xlib_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to an X11 window, using the Xlib client-side library, as well as a query to determine support for rendering via Xlib.

The "VK_KHR_xcb_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to an X11 window, using the XCB client-side library, as well as a query to determine support for rendering via XCB.

The "VK_KHR_wayland_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to a Wayland wl_surface, as well as a query to determine support for rendering to the windows desktop.

The "VK_KHR_mir_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to a Mir surface, as well as a query to determine support for rendering to the windows desktop.

The "VK_KHR_android_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to an ANativeWindow, Android’s native surface type. The ANativeWindow represents the producer endpoint of any buffer queue, regardless of consumer endpoint. Common consumer endpoints for ANativeWindows are the system window compositor, video encoders, and application-specific compositors importing the images through a SurfaceTexture.

The "VK_KHR_win32_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to a Win32 HWND, as well as a query to determine support for rendering to the windows desktop.

This extension defines a way for layers and the implementation to call back to the application for events of interest to the application.

The "VK_KHR_surface" extension is an instance extension. It introduces objects, which abstract native platform surface or window objects for use with Vulkan. It also provides a way to determine whether a queue family in a physical device supports presenting to particular surface. Separate extensions for each each platform provide the mechanisms for creating objects, but once created they may be used in this and other platform-independent extensions, in particular the "VK_KHR_swapchain" extension.

Applications may wish to import memory from the Direct 3D API, or export memory to other Vulkan instances. This extension provides a set of capability queries that allow applications determine what types of win32 memory handles an implementation supports for a given set of use cases.

This extension provides new entry points to query device features, device properties, and format properties in a way that can be easily extended by other extensions, without introducing any further entry points. The Vulkan 1.0 feature/limit/formatproperty structures do not include a Type/Next, this extension wraps them in new structures with Type/Next so an application can query a chain of feature/limit/formatproperty structures by constructing the chain and letting the implementation fill them in. A new command is added for each .Get* command in core Vulkan 1.0. The new feature structure (and a chain of extensions) can also be passed in to device creation to enable features.

This extension provides the VkValidationFlagsEXT struct that can be included in the chain at instance creation time. The new struct contains an array of VkValidationCheckEXT values that will be disabled by the validation layers.

The "VK_NN_vi_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) associated with an nn::vi::Layer.

This is extension, along with related platform exentions, allows applications to take exclusive control of displays associated with a native windowing system. This is especially useful for virtual reality applications that wish to hide HMDs (head mounted displays) from the native platform’s display management system, desktop, and/or other applications.

This extension allows an application to take exclusive control on a display currently associated with an X11 screen. When control is acquired, the display will be deassociated from the X11 screen until control is released or the specified display connection is closed. Essentially, the X11 screen will behave as if the monitor has been unplugged until control is released.

This is extension defines a vertical blanking period counter associated with display surfaces. It provides a mechanism to query support for such a counter from a object.

This extension defines additional enums for .

This extension provides instance-level commands to enumerate groups of physical devices, and to create a logical device from a subset of one of those groups. Such a logical device can then be used with new features in the "VK_KHX_device_group" extension.

An application may wish to reference device memory in multiple Vulkan logical devices or instances, in multiple processes, and/or in multiple APIs. This extension provides a set of capability queries and handle definitions that allow an application to determine what types of "external" memory handles an implementation supports for a given set of use cases.

An application may wish to reference device semaphores in multiple Vulkan logical devices or instances, in multiple processes, and/or in multiple APIs. This extension provides a set of capability queries and handle definitions that allow an application to determine what types of “external” semaphore handles an implementation supports for a given set of use cases.

An application may wish to reference device fences in multiple Vulkan logical devices or instances, in multiple processes, and/or in multiple APIs. This extension provides a set of capability queries and handle definitions that allow an application to determine what types of "external" fence handles an implementation supports for a given set of use cases.

This extension provides new entry points to query device surface capabilities in a way that can be easily extended by other extensions, without introducing any further entry points.

The "VK_MVK_ios_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to a UIView, the native surface type of iOS, which is underpinned by a CAMetalLayer, to support rendering to the surface using Apple’s Metal framework.

The "VK_MVK_macos_surface" extension is an instance extension. It provides a mechanism to create a object (defined by the "VK_KHR_surface" extension) that refers to an NSView, the native surface type of macOS, which is underpinned by a CAMetalLayer, to support rendering to the surface using Apple’s Metal framework.

Provides name constants for common Vulkan device extensions.

This extension is the device-level companion to the "VK_KHR_surface" extension. It introduces objects, which provide the ability to present rendering results to a surface.

This extension provides the API to enumerate displays and available modes on a given device.

This extension provides an API to create a swapchain directly on a device’s display without any underlying window system.

Implementations that expose this function allow GLSL shaders to be referenced by as an alternative to SPIR-V shaders.

This extension extends the set of sampler address modes to include an additional mode () that effectively uses a texture map twice as large as the original image in which the additional half of the new image is a mirror image of the original image.

This extension adds an additional, high quality cubic filtering mode to Vulkan, using a Catmull-Rom bicubic filter.

This extension introduces the possibility for the application to control the order of primitive rasterization.

This extension adds support for the "SPV_AMD_shader_trinary_minmax" SPIR-V extension.

This extension adds support for the "SPV_AMD_shader_explicit_vertex_parameter" SPIR-V extension.

This extension introduces concepts of object naming and tagging, for better tracking of Vulkan objects, as well as additional commands for recording annotations of named sections of a workload to aid organisation and offline analysis in external tools.

This extension adds support for the "SPV_AMD_gcn_shader" SPIR-V extension.

This extension allows device memory to be allocated for a particular buffer or image resource, which on some devices can significantly improve the performance of that resource.

This extension allows an application to source the number of draw calls for indirect draw calls from a buffer.

This extension allows an application to specify a negative viewport height.

This extension adds support for the "SPV_AMD_gpu_shader_half_float" SPIR-V extension.

This extension adds support for the "SPV_AMD_shader_ballot" SPIR-V extension.

This extension enables applications to create exportable Vulkan memory objects such that the underlying resources can be referenced outside the Vulkan instance that created them.

This extension enables win32 applications to export win32 handles from Vulkan memory objects such that the underlying resources can be referenced outside the Vulkan instance that created them, and import win32 handles created in the Direct3D API to Vulkan memory objects.

This extension provides a way for an application to access the keyed mutex associated with an imported Vulkan memory object when submitting command buffers to a queue.

This extension adds support for the "SPV_KHR_shader_draw_parameters" SPIR-V extension.

This extension adds support for the "SPV_KHR_shader_ballot" SPIR-V extension.

This extension adds support for the "SPV_KHR_subgroup_vote" SPIR-V extension.

This extension adds a collection of minor features that were intentionally left out or overlooked from the original Vulkan 1.0 release.

This extension allows the device to generate a number of critical commands for command buffers.

This extension defines a set of utility functions for use with the "VK_KHR_display" and "VK_KHR_display_swapchain" extensions.

This extension defines two new structures and a function to assign SMPTE (the Society of Motion Picture and Television Engineers) 2086 metadata and CTA (Consumer Technology Assocation) 861.3 metadata to a swapchain.

This extension allows an application that uses the "VK_KHR_swapchain" extension to obtain information about the presentation engine's display, to obtain timing information about each present, and to schedule a present to happen no earlier than a desired time.

This extension has the same goal as the OpenGL ES "GL_OVR_multiview" extension - it enables rendering to multiple "views" by recording a single set of commands to be executed with slightly different behavior for each view.

This extension provides functionality to use a logical device that consists of multiple physical devices, as created with the "VK_KHX_device_group_creation" extension.

This extension enables an application to export non-Vulkan handles from Vulkan memory objects such that the underlying resources can be referenced outside the scope of the Vulkan logical device that created them.

This extension enables an application to export Windows handles from Vulkan memory objects and to import Vulkan memory objects from Windows handles exported from other Vulkan memory objects or from similar resources in other APIs.

This extension enables an application to export POSIX file descriptor handles from Vulkan memory objects and to import Vulkan memory objects from POSIX file descriptor handles exported from other Vulkan memory objects or from similar resources in other APIs.

This extension provides a way for an application to access the keyed mutex associated with an imported Vulkan memory object when submitting command buffers to a queue.

This extension enables an application to create semaphores from which non-Vulkan handles that reference the underlying synchronization primitive can be exported.

This extension enables an application to export semaphore state to and import semaphore state from Windows handles.

This extension enables an application to export semaphore state to and import semaphore state from POSIX file descriptors.

This extension allows descriptors to be written into the command buffer, with the implementation being responsible for managing their memory.

The VK_KHR_16bit_storage extension allows use of 16-bit types in shader input and output interfaces, and push constant blocks.

This extension provides a way to update a fixed set of descriptors in a single with a pointer to a user defined data structure which describes the new descriptors.

This extension provides a mechanism to render VR scenes at a non-uniform resolution, in particular a resolution that falls linearly from the center towards the edges.

This extension adds support for the following SPIR-V extension in Vulkan: "SPV_NV_sample_mask_override_coverage".

This extension adds support for the following SPIR-V extension in Vulkan: "SPV_NV_geometry_shader_passthrough".

This extension adds support for the following SPIR-V extension in Vulkan: "SPV_NV_viewport_array2".

This extension adds a new way to write shaders to be used with multiview subpasses, where the attributes for all views are written out by a single invocation of the vertex processing stages.

This extension provides a new per-viewport swizzle that can modify the position of primitives sent to each viewport.

This extension provides additional orthogonally aligned "discard rectangles" specified in framebuffer-space coordinates that restrict rasterization of all points, lines and triangles.

This extension adds support for the following SPIR-V extension: "SPV_AMD_shader_trinary_minmax". Secondly, the extension allows the application to query, which formats can be used together with the new function prototypes introduced by the SPIR-V extension.

This extension extends VK_KHR_swapchain to enable creation of a shared presentable image. This allows the application to use the image while the presention engine is accessing it, in order to reduce the latency between rendering and presentation.

An application using external memory may wish to synchronize access to that memory using fences. This extension enables an application to create fences from which non-Vulkan handles that reference the underlying synchronization primitive can be exported.

An application using external memory may wish to synchronize access to that memory using fences. This extension enables an application to export fence payload to and import fence payload from Windows handles.

The VK_KHR_variable_pointers extension allows implementations to indicate their level of support for the SPV_KHR_variable_pointers SPIR-V extension.

This extension enables resources to be bound to a dedicated allocation, rather than suballocated.

This extension provides a new sampler parameter which allows applications to produce a filtered texel value by computing a component-wise minimum (MIN) or maximum (MAX) of the texels that would normally be averaged.

This extension adds support for the following SPIR-V extension in Vulkan: "SPV_KHR_storage_buffer_storage_class".

This extension adds support for the following SPIR-V extension in Vulkan: "SPV_AMD_gpu_shader_int16".

This extension provides new entry points to query memory requirements of images and buffers in a way that can be easily extended by other extensions, without introducing any further entry points.

This extension adds a number of "advanced" blending operations that can be used to perform new color blending operations, many of which are more complex than the standard blend modes provided by unextended Vulkan.

This extension allows the fragment coverage value, represented as an integer bitmask, to be substituted for a color output being written to a single-component color attachment with integer components (e.g. ).

This extension allows multisample rendering with a raster and depth/stencil sample count that is larger than the color sample count.

This extension adds a new enum where a triangle is rasterized by computing and filling its axis-aligned screen-space bounding box, disregarding the actual triangle edges.

Provides name constants for common Vulkan instance layers.

A built-in meta-layer definition which simplifies validation for applications. Specifying this short-hand layer definition will load a standard set of validation layers in the optimal order: "VK_LAYER_GOOGLE_threading" "VK_LAYER_LUNARG_parameter_validation" "VK_LAYER_LUNARG_device_limits" "VK_LAYER_LUNARG_object_tracker" "VK_LAYER_LUNARG_image" "VK_LAYER_LUNARG_core_validation" "VK_LAYER_LUNARG_swapchain" "VK_LAYER_GOOGLE_unique_objects"

Wrap all Vulkan objects in a unique pointer at create time and unwrap them at use time.

Print API calls and their parameters and values.

Validate that app properly queries features and obeys feature limitations.

Validate the descriptor set, pipeline state, and dynamic state; validate the interfaces between SPIR-V modules and the graphics pipeline; track and validate GPU memory and its binding to objects and command buffers.

Validate texture formats and render target formats.

Track all Vulkan objects and flag invalid objects and object memory leaks.

Validate API parameter values.

Validate the use of the WSI "swapchain" extensions.

Check validity of multi-threaded API usage.

Opaque handle to a descriptor pool object.

Gets the parent of the resource.

Resets a descriptor pool object. Resetting a descriptor pool recycles all of the resources from all of the descriptor sets allocated from the descriptor pool back to the descriptor pool, and the descriptor sets are implicitly freed.

Vulkan returns an error code.

Allocate one or more descriptor sets. The pool must have enough free descriptor capacity remaining to allocate the descriptor sets of the specified layouts. When a descriptor set is allocated, the initial state is largely uninitialized and all descriptors are undefined. However, the descriptor set can be bound in a command buffer without causing errors or exceptions. All entries that are statically used by a pipeline in a drawing or dispatching command must have been populated before the descriptor set is bound for use by that command. Entries that are not statically used by a pipeline can have uninitialized descriptors or descriptors of resources that have been destroyed, and executing a draw or dispatch with such a descriptor set bound does not cause undefined behavior. This means applications need not populate unused entries with dummy descriptors. If an allocation fails due to fragmentation, an indeterminate error is returned with an unspecified error code. Any returned error other than does not imply its usual meaning: applications should assume that the allocation failed due to fragmentation, and create a new descriptor pool.

The structure describing parameters of the allocation.

Update the contents of a descriptor set object. The operations described by are performed first, followed by the operations described by . Within each array, the operations are performed in the order they appear in the array. Each element in the array describes an operation updating the descriptor set using descriptors for resources specified in the structure. Each element in the array is a structure describing an operation copying descriptors between sets.

The structures describing the descriptor sets to write to. The structures describing the descriptor sets to copy between.

Free one or more descriptor sets.

An array of handles to objects. Vulkan returns an error code.

Destroy a descriptor pool object. When a pool is destroyed, all descriptor sets allocated from the pool are implicitly freed and become invalid. Descriptor sets allocated from a given pool do not need to be freed before destroying that descriptor pool.

Structure specifying parameters of a newly created descriptor pool.

A bitmask specifying certain supported operations on the pool.

The maximum number of descriptor sets that can be allocated from the pool.

Structures, each containing a descriptor type and number of descriptors of that type to be allocated in the pool.

Initializes a new instance of the structure.

The maximum number of descriptor sets that can be allocated from the pool. Structures, each containing a descriptor type and number of descriptors of that type to be allocated in the pool. A bitmask specifying certain supported operations on the pool.

Bitmask specifying certain supported operations on a descriptor pool.

No flags.

Specifies that descriptor sets can return their individual allocations to the pool, i.e. all of , , and are allowed. Otherwise, descriptor sets allocated from the pool must not be individually freed back to the pool, i.e. only and are allowed.

Structure specifying descriptor pool size.

The type of descriptor.

The number of descriptors of that type to allocate. Must be greater than 0.

Initializes a new instance of the structure.

The type of descriptor. The number of descriptors of that type to allocate.

Opaque handle to a descriptor set object. Descriptor sets are allocated from descriptor pool objects.

Gets the parent of the resource.

Free descriptor set.

Vulkan returns an error code.

Structure specifying the allocation parameters for descriptor sets.

Determines the number of descriptor sets to be allocated from the pool.

An array of , with each member specifying how the corresponding descriptor set is allocated. Array length must be greater than 0.

Initializes a new instance of the structure.

Determines the number of descriptor sets to be allocated from the pool. An array of descriptor set layouts, with each member specifying how the corresponding descriptor set is allocated.

Structure specifying the parameters of a descriptor set write operation.

The destination descriptor set to update.

The descriptor binding within that set.

The starting element in that array.

The number of descriptors to update (the number of elements in , , or ).

Specifies the type of each descriptor in , , or , as described below. It must be the same type as that specified in for at . The type of the descriptor also controls which array the descriptors are taken from.

An array of structures or is ignored.

An array of handles or is ignored.

Initializes a new instance of the structure.

The destination descriptor set to update. The descriptor binding within that set. The starting element in that array. The number of descriptors to update (the number of elements in , , or ). Specifies the type of each descriptor in , , or , as described below. It must be the same type as that specified in for at . The type of the descriptor also controls which array the descriptors are taken from. An array of structures or is ignored. An array of structures or is ignored. An array of handles or is ignored.

Specifies the type of a descriptor in a descriptor set.

Structure specifying descriptor image info.

A sampler handle, and is used in descriptor updates for types and if the binding being updated does not use immutable samplers.

An handle, and is used in descriptor updates for types , , , and .

The layout that the image subresources accessible from will be in at the time this descriptor is accessed. Is used in descriptor updates for types , , , and .

Initializes a new instance of the structure.

A sampler handle, and is used in descriptor updates for types and if the binding being updated does not use immutable samplers. An image view handle, and is used in descriptor updates for types , , , and . The layout that the image will be in at the time this descriptor is accessed. Is used in descriptor updates for types , , , and .

Structure specifying descriptor buffer info.

The resource.

The offset in bytes from the start of buffer. Access to buffer memory via this descriptor uses addressing that is relative to this starting offset.

The size in bytes that is used for this descriptor update, or to use the range from to the end of the buffer.

Initializes a new instance of the structure.

The buffer resource. The offset in bytes from the start of buffer. Access to buffer memory via this descriptor uses addressing that is relative to this starting offset. The size in bytes that is used for this descriptor update, or to use the range from to the end of the buffer.

Structure specifying a copy descriptor set operation.

Source .

Source binding. Must be a valid binding within . The sum of and must be less than or equal to the number of array elements in the descriptor set binding specified by , and all applicable consecutive bindings.

Array element within the source binding to copy from.

Destination .

Destination binding. Must be a valid binding within . The sum of and must be less than or equal to the number of array elements in the descriptor set binding specified by , and all applicable consecutive bindings. If is equal to , then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings.

Array element within the destination binding to copy to.

The number of descriptors to copy from the source to destination. If is greater than the number of remaining array elements in the source or destination binding, those affect consecutive bindings in a manner similar to .

Initializes a new instance of the structure.

Source descriptor set. Source binding. Array element within the source binding to copy from. Destination descriptor set. Destination binding. Array element within the destination binding to copy to. The number of descriptors to copy from the source to destination.

Opaque handle to a descriptor set layout object. A descriptor set layout object is defined by an array of zero or more descriptor bindings. Each individual descriptor binding is specified by a descriptor type, a count (array size) of the number of descriptors in the binding, a set of shader stages that can access the binding, and (if using immutable samplers) an array of sampler descriptors.

Gets the parent of the resource.

Destroy a descriptor set layout object.

Structure specifying parameters of a newly created descriptor set layout.

A bitmask specifying options for descriptor set layout creation.

An array of structures.

Initializes a new instance of the structure.

An array of structures.

Initializes a new instance of the structure.

An array of structures. A bitmask specifying options for descriptor set layout creation.

Bitmask specifying descriptor set layout properties.

No flags.

Specifies that descriptor sets must not be allocated using this layout, and descriptors are instead pushed by .

Structure specifying a descriptor set layout binding.

The binding number of this entry and corresponds to a resource of the same binding number in the shader stages.

Specifies which type of resource descriptors are used for this binding.

The number of descriptors contained in the binding, accessed in a shader as an array. If is zero this binding entry is reserved and the resource must not be accessed from any stage via this binding within any pipeline using the set layout.

Specifies which pipeline shader stages can access a resource for this binding. is a shorthand specifying that all defined shader stages, including any additional stages defined by extensions, can access the resource. If a shader stage is not included in , then a resource must not be accessed from that stage via this binding within any pipeline using the set layout. There are no limitations on what combinations of stages can be used by a descriptor binding, and in particular a binding can be used by both graphics stages and the compute stage.

Affects initialization of samplers. If specifies a or type descriptor, then can be used to initialize a set of immutable samplers. Immutable samplers are permanently bound into the set layout; later binding a sampler into an immutable sampler slot in a descriptor set is not allowed. If is not null, then it is considered to be an array of sampler handles that will be consumed by the set layout and used for the corresponding binding. If is null, then the sampler slots are dynamic and sampler handles must be bound into descriptor sets using this layout. If is not one of these descriptor types, then is ignored.

Initializes a new instance of the structure.

The binding number of this entry and corresponds to a resource of the same binding number in the shader stages. Specifies which type of resource descriptors are used for this binding. The number of descriptors contained in the binding, accessed in a shader as an array. If is zero this binding entry is reserved and the resource must not be accessed from any stage via this binding within any pipeline using the set layout. Specifies which pipeline shader stages can access a resource for this binding. is a shorthand specifying that all defined shader stages, including any additional stages defined by extensions, can access the resource. Affects initialization of samplers. If specifies a or type descriptor, then can be used to initialize a set of immutable samplers. Immutable samplers are permanently bound into the set layout; later binding a sampler into an immutable sampler slot in a descriptor set is not allowed. If is not null, then it is considered to be an array of sampler handles that will be consumed by the set layout and used for the corresponding binding. If is null, then the sampler slots are dynamic and sampler handles must be bound into descriptor sets using this layout. If is not one of these descriptor types, then is ignored.

Opaque handle to a device object.

Gets the parent of the resource.

Return a function handle for a command or if not found. In order to support systems with multiple Vulkan implementations comprising heterogeneous collections of hardware and software, the function pointers returned by may point to dispatch code, which calls a different real implementation for different objects (and objects created from them). The overhead of this internal dispatch can be avoided by obtaining device-specific function pointers for any commands that use a device or device-child object as their dispatchable object.

The name of the command to obtain. Function handle for a command or if not found. is null.

Return a function delegate for a command or null if not found. In order to support systems with multiple Vulkan implementations comprising heterogeneous collections of hardware and software, the function delegates returned by may point to dispatch code, which calls a different real implementation for different objects (and objects created from them). The overhead of this internal dispatch can be avoided by obtaining device-specific function delegate for any commands that use a device or device-child object as their dispatchable object.

The name of the command to obtain. Function delegate for a command or null if not found. is null.

Get a queue handle from a device.

The index of the queue family to which the queue belongs. Must be one of the queue family indices specified when device was created, via the structure. The index within this queue family of the queue to retrieve. Must be less than the number of queues created for the specified queue family index when device was created, via the length of . Handle to a queue.

Wait for a device to become idle. Equivalent to calling for all queues owned by device.

Vulkan returns an error code.

Create a new buffer object.

The structure containing parameters affecting creation of the buffer. Controls host memory allocation. Buffer object. Vulkan returns an error code.

Create a new image object.

The structure containing parameters to be used to create the image. Controls host memory allocation. Vulkan returns an error code.

Allocate GPU memory.

The structure describing parameters of the allocation. A successful returned allocation must use the requested parameters — no substitution is permitted by the implementation. Controls host memory allocation. Vulkan returns an error code.

Flush mapped memory range. Must be used to guarantee that host writes to non-coherent memory are visible to the device. It must be called after the host writes to non-coherent memory have completed and before command buffers that will read or write any of those memory locations are submitted to a queue. Unmapping non-coherent memory does not implicitly flush the mapped memory, and host writes that have not been flushed may not ever be visible to the device.

Structure describing the memory range to flush. Vulkan returns an error code.

Flush mapped memory ranges. Must be used to guarantee that host writes to non-coherent memory are visible to the device. It must be called after the host writes to non-coherent memory have completed and before command buffers that will read or write any of those memory locations are submitted to a queue. Unmapping non-coherent memory does not implicitly flush the mapped memory, and host writes that have not been flushed may not ever be visible to the device.

Structures describing the memory ranges to flush. Vulkan returns an error code.

Invalidate a range of mapped memory. Must be used to guarantee that device writes to non-coherent memory are visible to the host. It must be called after command buffers that execute and flush (via memory barriers) the device writes have completed, and before the host will read or write any of those locations. If a range of non-coherent memory is written by the host and then invalidated without first being flushed, its contents are undefined. Mapping non-coherent memory does not implicitly invalidate the mapped memory, and device writes that have not been invalidated must be made visible before the host reads or overwrites them.

Structure describing the memory range to invalidate. Vulkan returns an error code.

Invalidate ranges of mapped memory objects. Must be used to guarantee that device writes to non-coherent memory are visible to the host. It must be called after command buffers that execute and flush (via memory barriers) the device writes have completed, and before the host will read or write any of those locations. If a range of non-coherent memory is written by the host and then invalidated without first being flushed, its contents are undefined. Mapping non-coherent memory does not implicitly invalidate the mapped memory, and device writes that have not been invalidated must be made visible before the host reads or overwrites them.

Structures describing the memory ranges to invalidate. Vulkan returns an error code.

Creates a new shader module object.

The structure containing information of a newly created shader module. Controls host memory allocation. Resulting shader module object. Vulkan returns an error code.

Creates a new pipeline cache.

The structure containing information of a newly created pipeline cache. Controls host memory allocation. Resulting pipeline cache. Vulkan returns an error code.

Creates a new compute pipeline object.

Structure specifying parameters of a newly created compute pipeline. Is either null, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command. Controls host memory allocation. The resulting compute pipeline object. Vulkan returns an error code.

Create new compute pipeline objects.

Structures specifying parameters of newly created compute pipelines. If the flags member of any given element contains the flag, and the member of that same element is not -1, must be less than the index into that corresponds to that element Is either null, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command. Controls host memory allocation. An array in which the resulting compute pipeline objects are returned. Vulkan returns an error code.

Create a graphics pipeline.

Structure specifying parameters of a newly created graphics pipeline. Is either null, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command. Controls host memory allocation. The resulting graphics pipeline object. Vulkan returns an error code.

Create graphics pipelines.

Structures specifying parameters of newly created graphics pipelines. If the flags member of any given element contains the flag, and the member of that same element is not -1, must be less than the index into that corresponds to that element Is either null, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command. Controls host memory allocation. An array in which the resulting graphics pipeline objects are returned. Vulkan returns an error code.

Creates a new pipeline layout object.

The structure specifying the state of the pipeline layout object. Controls host memory allocation. Handle in which the resulting pipeline layout object is returned. Vulkan returns an error code.

Create a new sampler object.

The structure specifying the state of the sampler object. Controls host memory allocation. Resulting sampler object. Vulkan returns an error code.

Create a new descriptor set layout.

The structure specifying the state of the descriptor set layout object. Controls host memory allocation. The resulting descriptor set layout object. Vulkan returns an error code.

Creates a descriptor pool object.

The structure specifying the state of the descriptor pool object. Controls host memory allocation. The resulting descriptor pool object. Vulkan returns an error code.

Create a new render pass object.

The structure that describes the parameters of the render pass. Controls host memory allocation. The resulting render pass object. Vulkan returns an error code.

Create a new command pool object.

Contains information used to create the command pool. Controls host memory allocation. The created pool. Vulkan returns an error code.

Create a new event object.

Controls host memory allocation. The resulting event object.

Create a new fence object.

The structure which contains information about how the fence is to be created. Controls host memory allocation. The resulting fence object.

Resets one or more fence objects. Defines a fence unsignal operation for each fence, which resets the fence to the unsignaled state. If any member of is already in the unsignaled state, then the command has no effect on that fence.

Fence handles to reset. Vulkan returns an error code.

Wait for one or more fences to become signaled. If the condition is satisfied when the command is called, then the command returns immediately. If the condition is not satisfied at the time the command is called, then the command will block and wait up to timeout nanoseconds for the condition to become satisfied.

Fence handle. The condition that must be satisfied to successfully unblock the wait. If true , then the condition is that all fences in are signaled. Otherwise, the condition is that at least one fence in is signaled. The timeout period in units of nanoseconds. Timeout is adjusted to the closest value allowed by the implementation-dependent timeout accuracy, which may be substantially longer than one nanosecond, and may be longer than the requested period. If timeout is zero, then the command does not wait, but simply returns the current state of the fences. The result will be thrown in this case if the condition is not satisfied, even though no actual wait was performed. If the specified timeout period expires before the condition is satisfied, the command throws with . If the condition is satisfied before timeout nanoseconds has expired, the command returns successfully. Vulkan returns an error code.

Create a new queue semaphore object.

Controls host memory allocation. Resulting semaphore object. Vulkan returns an error code.

Create a new query pool object.

Structure containing the number and type of queries to be managed by the pool. Controls host memory allocation. The resulting query pool object. Vulkan returns an error code.

Destroy a logical device.

Structure specifying parameters of a newly created device.

Is or a pointer to an extension-specific structure.

Structures describing the queues that are requested to be created along with the logical device.

Is null or unicode strings containing the names of extensions to enable for the created device.

Is null or a structure that contains boolean indicators of all the features to be enabled.

Initializes a new instance of the structure.

Structures describing the queues that are requested to be created along with the logical device. Is null or unicode strings containing the names of extensions to enable for the created device. Is null or a structure that contains boolean indicators of all the features to be enabled. Is or a pointer to an extension-specific structure.

Structure specifying parameters of a newly created device queue.

Initializes a new instance of the structure.

An unsigned integer indicating the index of the queue family to create on this device. This index corresponds to the index of an element of the array that was returned by . An unsigned integer specifying the number of queues to create in the queue family indicated by . Normalized floating point values, specifying priorities of work that will be submitted to each created queue.

An unsigned integer indicating the index of the queue family to create on this device. This index corresponds to the index of an element of the array that was returned by .

An unsigned integer specifying the number of queues to create in the queue family indicated by .

An array of normalized floating point values, specifying priorities of work that will be submitted to each created queue.

Structure specifying a mapped memory range.

The memory object to which this range belongs. Must currently be mapped.

The zero-based byte offset from the beginning of the memory object. Must be a multiple of . If is equal to , offset must be within the currently mapped range of memory

Is either the size of range, or to affect the range from offset to the end of the current mapping of the allocation. If size is not equal to , offset and size must specify a range contained within the currently mapped range of memory. If size is not equal to , size must be a multiple of

Initializes a new instance of the structure.

The memory object to which this range belongs. The zero-based byte offset from the beginning of the memory object. Is either the size of range, or to affect the range from offset to the end of the current mapping of the allocation.

Opaque handle to a device memory object. A Vulkan device operates on data in device memory via memory objects that are represented in the API by a handle.

Gets the owner of the resource.

Map a memory object into application address space. It is an application error to call on a memory object that is already mapped. Will fail if the implementation is unable to allocate an appropriately sized contiguous virtual address range, e.g. due to virtual address space fragmentation or platform limits. In such cases, must return . The application can improve the likelihood of success by reducing the size of the mapped range and/or removing unneeded mappings using . Does not check whether the device memory is currently in use before returning the host-accessible pointer. The application must guarantee that any previously submitted command that writes to this range has completed before the host reads from or writes to that range, and that any previously submitted command that reads from that range has completed before the host writes to that region (see here for details on fulfilling such a guarantee). If the device memory was allocated without the set, these guarantees must be made for an extended range: the application must round down the start of the range to the nearest multiple of , and round the end of the range up to the nearest multiple of . While a range of device memory is mapped for host access, the application is responsible for synchronizing both device and host access to that memory range.

A zero-based byte offset from the beginning of the memory object. The size of the memory range to map, or to map from offset to the end of the allocation. A pointer in which is returned a host-accessible pointer to the beginning of the mapped range. This pointer minus offset must be aligned to at least . Vulkan returns an error code.

Unmap a previously mapped memory object.

Query the current commitment for a . The implementation may update the commitment at any time, and the value returned by this query may be out of date. The implementation guarantees to allocate any committed memory from the indicated by the memory type that the memory object was created with.

The number of bytes currently committed.

Free GPU memory. Before freeing a memory object, an application must ensure the memory object is no longer in use by the device—for example by command buffers queued for execution. The memory can remain bound to images or buffers at the time the memory object is freed, but any further use of them (on host or device) for anything other than destroying those objects will result in undefined behavior. If there are still any bound images or buffers, the memory may not be immediately released by the implementation, but must be released by the time all bound images and buffers have been destroyed. Once memory is released, it is returned to the heap from which it was allocated. If a memory object is mapped at the time it is freed, it is implicitly unmapped.

Structure containing parameters of a memory allocation.

Is or a pointer to an extension-specific structure.

The size of the allocation in bytes. Must be greater than 0.

The memory type index, which selects the properties of the memory to be allocated, as well as the heap the memory will come from.

Initializes a new instance of structure.

The size of the allocation in bytes. Must be greater than 0. The memory type index, which selects the properties of the memory to be allocated, as well as the heap the memory will come from. Is or a pointer to an extension-specific structure.

Opaque handle to a event object. Events are a synchronization primitive that can be used to insert a fine-grained dependency between commands submitted to the same queue, or between the host and a queue. Events have two states - signaled and unsignaled. An application can signal an event, or unsignal it, on either the host or the device. A device can wait for an event to become signaled before executing further operations. No command exists to wait for an event to become signaled on the host, but the current state of an event can be queried.

Gets the parent of this resource.

Retrieve the status of an event object. Upon success, the command returns the state of the event object with the following return codes: * - The event is signaled * - The event is unsignaled

if the event is signaled; otherwise . Vulkan returns an error code.

Set an event to signaled state.

Vulkan returns an error code.

Reset an event to non-signaled state.

Vulkan returns an error code.

Destroy an event object.

Structure specifying parameters of a newly created event.

Structure specifying a two-dimensional extent.

A special valued .

An with all of its components set to zero.

The width component of the extent.

The height component of the extent.

Initializes a new instance of structure.

The width component of the extent. The height component of the extent.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns the hash code for this instance.

The hash code.

Returns a boolean indicating whether the two given extents are equal.

The first extent to compare. The second extent to compare. true if the extents are equal; false otherwise.

Returns a boolean indicating whether the two given extents are not equal.

The first extent to compare. The second extent to compare. true if the extents are not equal; false if they are equal.

Structure specifying a three-dimensional extent.

A special valued .

An with all of its components set to zero.

The width component of the extent.

The height component of the extent.

The depth component of the extent.

Initializes a new instance of structure.

The width component of the extent. The height component of the extent. The depth component of the extent.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns the hash code for this instance.

The hash code.

Returns a boolean indicating whether the two given extents are equal.

The first extent to compare. The second extent to compare. true if the extents are equal; false otherwise.

Returns a boolean indicating whether the two given extents are not equal.

The first extent to compare. The second extent to compare. true if the extents are not equal; false if they are equal.

Provides extension methods for the class.

Open a command buffer marker region. Typical Vulkan applications will submit many command buffers in each frame, with each command buffer containing a large number of individual commands. Being able to logically annotate regions of command buffers that belong together as well as hierarchically subdivide the frame is important to a developer’s ability to navigate the commands viewed holistically. The marker commands and define regions of a series of commands that are grouped together, and they can be nested to create a hierarchy.

The command buffer into which the command is recorded. Specifies the parameters of the marker region to open.

Close a command buffer marker region. Typical Vulkan applications will submit many command buffers in each frame, with each command buffer containing a large number of individual commands. Being able to logically annotate regions of command buffers that belong together as well as hierarchically subdivide the frame is important to a developer’s ability to navigate the commands viewed holistically. The marker commands and define regions of a series of commands that are grouped together, and they can be nested to create a hierarchy.

The command buffer into which the command is recorded.

Insert a marker label into a command buffer. Allows insertion of a single label within a command buffer.

The command buffer into which the command is recorded. Specifies the parameters of the marker to insert.

If the pipeline state object was created with the dynamic state enabled, the discard rectangles are dynamically set and changed with this command.

The command buffer into which the command will be recorded. The index of the first discard rectangle whose state is updated by the command. Structures specifying discard rectangles.

Specify parameters of a command buffer marker region.

A unicode string that contains the name of the marker.

An optional RGBA color value that can be associated with the marker. A particular implementation may choose to ignore this color value. The values contain RGBA values in order, in the range 0.0 to 1.0. If all elements in color are set to 0.0 then it is ignored.

Initializes a new instance of the structure.

A unicode string that contains the name of the marker. An optional RGBA color value that can be associated with the marker. A particular implementation may choose to ignore this color value. The values contain RGBA values in order, in the range 0.0 to 1.0. If all elements in color are set to 0.0 then it is ignored.

Opaque handle to a debug report callback object.

Gets the parent of the resource.

Destroy a debug report callback object.

Structure specifying parameters of a newly created debug report callback. For each that is created the flags determine when that function is called. A callback will be made for issues that match any bit set in its flags. The callback will come directly from the component that detected the event, unless some other layer intercepts the calls for its own purposes (filter them in different way, log to system error log, etc.) An application may receive multiple callbacks if multiple objects were created. A callback will always be executed in the same thread as the originating Vulkan call. A callback may be called from multiple threads simultaneously (if the application is making Vulkan calls from multiple threads).

A bitmask specifying which event(s) will cause this callback to be called. Flags are interpreted as bitmasks and multiple can be set.

The application callback function to call.

User data to be passed to the callback.

Initializes a new instance of the structure.

A bitmask specifying which event(s) will cause this callback to be called. Flags are interpreted as bitmasks and multiple can be set. The application callback function to call. User data to be passed to the callback.

Structure specifying arguments for a debug report callback function.

The that triggered this callback.

The specifying the type of object being used or created at the time the event was triggered.

The object where the issue was detected. may be 0 if there is no object associated with the event.

The component (layer, driver, loader) defined value that indicates the location of the trigger. This is an optional value.

The layer-defined value indicating what test triggered this callback.

The abbreviation of the component making the callback.

The string detailing the trigger conditions.

The user data given when the was created.

Bitmask specifying events which cause a debug report callback.

Specifies an informational message such as resource details that may be handy when debugging an application.

Specifies use of Vulkan that may expose an app bug. Such cases may not be immediately harmful, such as a fragment shader outputting to a location with no attachment. Other cases may point to behavior that is almost certainly bad when unintended such as using an image whose memory has not been filled. In general if you see a warning but you know that the behavior is intended/desired, then simply ignore the warning.

Specifies a potentially non-optimal use of Vulkan. E.g. using when a load op would have worked.

Specifies that an error that may cause undefined results, including an application crash.

Specifies diagnostic information from the loader and layers.

All flags.

Specify the type of an object handle.

Specifies an unknown object.

Specifies an .

Specifies a .

Specifies an .

Specifies a .

Specifies an .

Specifies a .

Provides extension methods for the class.

Give a user-friendly name to an object. Applications may change the name associated with an object simply by calling again with a new string. To remove a previously set name, name should be set to an empty string.

The device that created the object. Specifies the parameters of the name to set on the object. Vulkan returns an error code.

Attach arbitrary data to an object. In addition to setting a name for an object, debugging and validation layers may have uses for additional binary data on a per-object basis that has no other place in the Vulkan API. For example, a could have additional debugging data attached to it to aid in offline shader tracing.

The device that created the object. Specifies the parameters of the tag to attach to the object. Vulkan returns an error code.

Set the power state of a display.

The display whose power state is modified. A logical device associated with . Specifies the new power state of . Vulkan returns an error code.

Signal a fence when a device event occurs.

A logical device on which the event may occur. A structure describing the event of interest to the application. Controls host memory allocation. The resulting fence object. Vulkan returns an error code.

Signal a fence when a display event occurs.

A logical device associated with . The display on which the event may occur. The structure describing the event of interest to the application. Controls host memory allocation. The resulting fence object. Vulkan returns an error code.

Function to set HDR metadata.

The logical device where the swapchain(s) were created. The array of handles. The array of structures.

Specify parameters of a name to give to an object.

Specifies specifying the type of the object to be named.

The object to be named.

A unicode string specifying the name to apply to object.

Initializes a new instance of the structure.

Vulkan object to be name. Name to set.

Initializes a new instance of the structure.

Vulkan object to name. Name to set.

Specify parameters of a tag to attach to an object.

Specifies the type of the object to be named.

The object to be tagged.

A numerical identifier of the tag.

Bytes containing the data to be associated with the object.

Initializes a new instance of the structure.

Vulkan object to be tagged. A numerical identifier of the tag. Bytes containing the data to be associated with the object.

Initializes a new instance of the structure.

Vulkan object to be tagged. A numerical identifier of the tag. Bytes containing the data to be associated with the object.

Describe the power state of a display.

The new power state of the display.

Initializes a new instance of the structure.

The new power state of the display.

Possible power states for a display.

Specifies that the display is powered down.

Specifies that the display is in a low power mode, but may be able to transition back to more quickly than if it were in . This state may be the same as .

Specifies that the display is powered on.

Describe a device event to create.

Specifies when the fence will be signaled.

Initializes a new instance of the structure.

Specifies when the fence will be signaled.

Describe a display event to create.

Specifies when the fence will be signaled.

Initializes a new instance of the structure.

Specifies when the fence will be signaled.

Events that can occur on a device object.

Specifies that the fence is signaled when a display is plugged into or unplugged from the specified device. Applications can use this notification to determine when they need to re-enumerate the available displays on a device.

Events that can occur on a display object.

Specifies that the fence is signaled when the first pixel of the next display refresh cycle leaves the display engine for the display.

Structure to specify HDR metadata.

Is or a pointer to an extension-specific structure.

The mastering display's red primary in chromaticity coordinates.

The mastering display's green primary in chromaticity coordinates.

The mastering display's blue primary in chromaticity coordinates.

The mastering display's white-point in chromaticity coordinates.

The maximum luminance of the mastering display in nits.

The minimum luminance of the mastering display in nits.

Content's maximum luminance in nits.

The maximum frame average light level in nits.

Structure to specify X,Y chromaticity coordinates.

The X coordinate of chromaticity limited to between 0 and 1.

The Y coordinate of chromaticity limited to between 0 and 1.

Provides extension methods for the class.

Acquire access to a DisplayKhr using Xlib. All permissions necessary to control the display are granted to the Vulkan instance associated with until the display is released or the X11 connection specified by is terminated. Permission to access the display may be temporarily revoked during periods when the X11 server from which control was acquired itself looses access to . During such periods, operations which require access to the display must fail with an approriate error code. If the X11 server associated with does not own , or if permission to access it has already been acquired by another entity, the call must throw with the error code .

Vulkan returns an error code.

Release access to an acquired DisplayKhr.

The display to release control of. Vulkan returns an error code.

Provides extension methods for the class.

Create a debug report callback object.

The instance the callback will be logged on. The structure which defines the conditions under which this callback will be called. Controls host memory allocation. A handle. Vulkan command not found. Vulkan returns an error code.

To inject it's own messages into the debug stream an application uses this method.

The instance the callback will be logged on. Indicates the that triggered this callback. The type of object being used / created at the time the event was triggered. Gives the object where the issue was detected. Object may be 0 if there is no object associated with the event. A component (layer, driver, loader) defined value that indicates the "location" of the trigger. This is an optional value. A layer defined value indicating what test triggered this callback. Abbreviation of the component making the callback. Unicode string detailing the trigger conditions. Vulkan command not found.

Specify validation checks to disable for a Vulkan instance.

The type of this structure.

Is or a pointer to an extension-specific structure.

The number of checks to disable.

A pointer to an array of values specifying the validation checks to be disabled.

Specify validation checks to disable.

Specifies that all validation checks are disabled.

Specifies that shader validation is disabled.

Provides extension methods for the class.

Query surface capabilities.

The physical device that will be associated with the swapchain to be created, as described for . The surface that will be associated with the swapchain. The structure in which the capabilities are returned. Vulkan returns an error code.

Query the corresponding to an X11 RandR Output. When acquiring displays from an X11 server, an application may also wish to enumerate and identify them using a native handle rather than a handle.

The physical device to query the display handle on. A connection to the X11 server from which was queried. An X11 RandR output ID. The corresponding handle. Vulkan returns an error code.

Structure describing capabilities of a surface.

Is or a pointer to an extension-specific structure.

The minimum number of images the specified device supports for a swapchain created for the surface, and will be at least one.

The maximum number of images the specified device supports for a swapchain created for the surface, and will be either 0, or greater than or equal to . A value of 0 means that there is no limit on the number of images, though there may be limits related to the total amount of memory used by swapchain images.

The current width and height of the surface, or the special value indicating that the surface size will be determined by the extent of a swapchain targeting the surface.

Contains the smallest valid swapchain extent for the surface on the specified device. The width and height of the extent will each be less than or equal to the corresponding width and height of , unless has the special value described above.

Contains the largest valid swapchain extent for the surface on the specified device. The width and height of the extent will each be greater than or equal to the corresponding width and height of . The width and height of the extent will each be greater than or equal to the corresponding width and height of , unless has the special value described above.

The maximum number of layers swapchain images can have for a swapchain created for this device and surface, and will be at least one.

A bitmask of , describing the presentation transforms supported for the surface on the specified device, and at least one bit will be set.

The surface's current transform relative to the presentation engine's natural orientation, as described by .

A bitmask of , representing the alpha compositing modes supported by the presentation engine for the surface on the specified device, and at least one bit will be set. Opaque composition can be achieved in any alpha compositing mode by either using a swapchain image format that has no alpha component, or by ensuring that all pixels in the swapchain images have an alpha value of 1.0.

A bitmask of representing the ways the application can use the presentable images of a swapchain created for the surface on the specified device. must be included in the set but implementations may support additional usages.

A bitfield containing one bit set for each surface counter type supported.

Surface-relative counter types.

No flags.

Indicates a counter incrementing once every time a vertical blanking period occurs on the display associated with the surface.

Structure describing discard rectangle limits that can be supported by an implementation.

Pointer to next structure.

Max number of active discard rectangles.

Structure describing advanced blending features that can be supported by an implementation.

Pointer to next structure.

Structure describing advanced blending limits that can be supported by an implementation.

Pointer to next structure.

Structure specifying discard rectangle.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is reserved for future use.

The mode used to determine whether fragments that lie within the discard rectangle are discarded or not.

The number of discard rectangles used by the pipeline.

A pointer to an array of structures, defining the discard rectangles. If the discard rectangle state is dynamic, this member is ignored.

Initializes a new instance of the structure.

The mode used to determine whether fragments that lie within the discard rectangle are discarded or not. The number of discard rectangles used by the pipeline. A pointer to an array of structures, defining the discard rectangles. If the discard rectangle state is dynamic, this member is ignored. Is or a pointer to an extension-specific structure.

No flags.

Specify the discard rectangle mode.

Specifies that a fragment within any discard rectangle satisfies the test.

Specifies that a fragment not within any of the discard rectangles satisfies the test.

Enumerant specifying the blend overlap parameter.

Specifies that there is no correlation between the source and destination coverage.

Specifies that the source and destination coverage are considered to have minimal overlap.

Specifies that the source and destination coverage are considered to have maximal overlap.

Structure specifying parameters that affect advanced blend operations.

The type of this structure.

Is or a pointer to an extension-specific structure.

Specifies whether the source color of the blend operation is treated as premultiplied.

Specifies whether the destination color of the blend operation is treated as premultiplied.

Specifies how the source and destination sample's coverage is correlated.

Structure specifying parameters controlling coverage modulation.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is reserved for future use.

Controls which color components are modulated and is of type .

Controls whether the modulation factor is looked up from a table in .

The number of elements in .

A pointer to a table of modulation factors containing a value for each number of covered samples.

No flags.

Specify the discard rectangle mode.

Specifies that no components are multiplied by the modulation factor.

Specifies that the red, green, and blue components are multiplied by the modulation factor.

Specifies that the alpha component is multiplied by the modulation factor.

Specifies that all components are multiplied by the modulation factor.

Specify reduction mode for texture filtering.

Indicates that texel values are combined by computing a weighted average of values in the footprint, using weights.

Indicates that texel values are combined by taking the component-wise minimum of values in the footprint with non-zero weights.

Indicates that texel values are combined by taking the component-wise maximum of values in the footprint with non-zero weights.

Structure describing sampler filter minmax limits that can be supported by an implementation.

Pointer to next structure.

Structure specifying sampler reduction mode.

The type of this structure.

Is or a pointer to an extension-specific structure.

Controls how texture filtering combines texel values.

Provides extension methods for the class.

Query the current value of a surface counter. The requested counters become active when the first presentation command for the associated swapchain is processed by the presentation engine.

The swapchain from which to query the counter value. The counter to query. The current value of the counter. Vulkan returns an error code.

Opaque handle to a fence object. Fences are a synchronization primitive that can be used to insert a dependency from a queue to the host. Fences have two states - signaled and unsignaled. A fence can be signaled as part of the execution of a queue submission command. Fences can be unsignaled on the host with . Fences can be waited on by the host with the command, and the current state can be queried with .

Gets the parent of this resource.

Return the status of a fence. Upon success, returns the status of the fence object, with the following return codes: * - The fence is signaled * - The fence is unsignaled

if the fence is signaled; otherwise . Vulkan returns an error code.

Resets the fence object. Defines a fence unsignal operation, which resets the fence to the unsignaled state. If fence is already in the unsignaled state, then the command has no effect on that fence.

Vulkan returns an error code.

Wait for the fence to become signaled. If the condition is satisfied when the command is called, then the command returns immediately. If the condition is not satisfied at the time the command is called, then the command will block and wait up to timeout nanoseconds for the condition to become satisfied.

The timeout period in units of nanoseconds. Timeout is adjusted to the closest value allowed by the implementation-dependent timeout accuracy, which may be substantially longer than one nanosecond, and may be longer than the requested period. If timeout is zero, then the command does not wait, but simply returns the current state of the fences. The result will be thrown in this case if the condition is not satisfied, even though no actual wait was performed. If the specified timeout period expires before the condition is satisfied, the command throws with . If the condition is satisfied before timeout nanoseconds has expired, the command returns successfully. Vulkan returns an error code.

Destroy a fence object.

Structure specifying parameters of a newly created fence.

Specifies the initial state and behavior of the fence.

Initializes a new instance of the structure.

Specifies the initial state and behavior of the fence.

Bitmask specifying initial state and behavior of a fence.

Specifies that the fence object is created in the unsignaled state.

Specifies that the fence object is created in the signaled state. Otherwise, it is created in the unsignaled state.

Available image formats.

Indicates that the format is not specified.

Specifies a two-component, 8-bit packed unsigned normalized format that has a 4-bit R component in bits 4..7, and a 4-bit G component in bits 0..3.

Specifies a four-component, 16-bit packed unsigned normalized format that has a 4-bit R component in bits 12..15, a 4-bit G component in bits 8..11, a 4-bit B component in bits 4..7, and a 4-bit A component in bits 0..3.

Specifies a four-component, 16-bit packed unsigned normalized format that has a 4-bit B component in bits 12..15, a 4-bit G component in bits 8..11, a 4-bit R component in bits 4..7, and a 4-bit A component in bits 0..3.

Specifies a three-component, 16-bit packed unsigned normalized format that has a 5-bit R component in bits 11..15, a 6-bit G component in bits 5..10, and a 5-bit B component in bits 0..4.

Specifies a three-component, 16-bit packed unsigned normalized format that has a 5-bit B component in bits 11..15, a 6-bit G component in bits 5..10, and a 5-bit R component in bits 0..4.

Specifies a four-component, 16-bit packed unsigned normalized format that has a 5-bit R component in bits 11..15, a 5-bit G component in bits 6..10, a 5-bit B component in bits 1..5, and a 1-bit A component in bit 0.

Specifies a four-component, 16-bit packed unsigned normalized format that has a 5-bit B component in bits 11..15, a 5-bit G component in bits 6..10, a 5-bit R component in bits 1..5, and a 1-bit A component in bit 0.

Specifies a four-component, 16-bit packed unsigned normalized format that has a 1-bit A component in bit 15, a 5-bit R component in bits 10..14, a 5-bit G component in bits 5..9, and a 5-bit B component in bits 0..4.

Specifies a one-component, 8-bit unsigned normalized format that has a single 8-bit R component.

Specifies a one-component, 8-bit signed normalized format that has a single 8-bit R component.

Specifies a one-component, 8-bit unsigned scaled integer format that has a single 8-bit R component.

Specifies a one-component, 8-bit signed scaled integer format that has a single 8-bit R component.

Specifies a one-component, 8-bit unsigned integer format that has a single 8-bit R component.

Specifies a one-component, 8-bit signed integer format that has a single 8-bit R component.

Specifies a one-component, 8-bit unsigned normalized format that has a single 8-bit R component stored with sRGB nonlinear encoding.

Specifies a two-component, 16-bit unsigned normalized format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

Specifies a two-component, 16-bit signed normalized format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

Specifies a two-component, 16-bit unsigned scaled integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

Specifies a two-component, 16-bit signed scaled integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

Specifies a two-component, 16-bit unsigned integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

Specifies a two-component, 16-bit signed integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

Specifies a two-component, 16-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, and an 8-bit G component stored with sRGB nonlinear encoding in byte 1.

Specifies a three-component, 24-bit unsigned normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

Specifies a three-component, 24-bit signed normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

Specifies a three-component, 24-bit unsigned scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

Specifies a three-component, 24-bit signed scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

Specifies a three-component, 24-bit unsigned integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

Specifies a three-component, 24-bit signed integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

Specifies a three-component, 24-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, and an 8-bit B component stored with sRGB nonlinear encoding in byte 2.

Specifies a three-component, 24-bit unsigned normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

Specifies a three-component, 24-bit signed normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

Specifies a three-component, 24-bit unsigned scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

Specifies a three-component, 24-bit signed scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

Specifies a three-component, 24-bit unsigned integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

Specifies a three-component, 24-bit signed integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

Specifies a three-component, 24-bit unsigned normalized format that has an 8-bit B component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, and an 8-bit R component stored with sRGB nonlinear encoding in byte 2.

Specifies a four-component, 32-bit unsigned normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit signed normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit unsigned scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit signed scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit unsigned integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit signed integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, an 8-bit B component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit unsigned normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit signed normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit unsigned scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit signed scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit unsigned integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit signed integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit unsigned normalized format that has an 8-bit B component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, an 8-bit R component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A component in byte 3.

Specifies a four-component, 32-bit packed unsigned normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

Specifies a four-component, 32-bit packed signed normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

Specifies a four-component, 32-bit packed unsigned scaled integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

Specifies a four-component, 32-bit packed signed scaled integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

Specifies a four-component, 32-bit packed unsigned integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

Specifies a four-component, 32-bit packed signed integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

Specifies a four-component, 32-bit packed unsigned normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component stored with sRGB nonlinear encoding in bits 16..23, an 8-bit G component stored with sRGB nonlinear encoding in bits 8..15, and an 8-bit R component stored with sRGB nonlinear encoding in bits 0..7.

Specifies a four-component, 32-bit packed unsigned normalized format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

Specifies a four-component, 32-bit packed signed normalized format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

Specifies a four-component, 32-bit packed unsigned scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

Specifies a four-component, 32-bit packed signed scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

Specifies a four-component, 32-bit packed unsigned integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

Specifies a four-component, 32-bit packed signed integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

Specifies a four-component, 32-bit packed unsigned normalized format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

Specifies a four-component, 32-bit packed signed normalized format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

Specifies a four-component, 32-bit packed unsigned scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

Specifies a four-component, 32-bit packed signed scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

Specifies a four-component, 32-bit packed unsigned integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

Specifies a four-component, 32-bit packed signed integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

Specifies a one-component, 16-bit unsigned normalized format that has a single 16-bit R component.

Specifies a one-component, 16-bit signed normalized format that has a single 16-bit R component.

Specifies a one-component, 16-bit unsigned scaled integer format that has a single 16-bit R component.

Specifies a one-component, 16-bit signed scaled integer format that has a single 16-bit R component.

Specifies a one-component, 16-bit unsigned integer format that has a single 16-bit R component.

Specifies a one-component, 16-bit signed integer format that has a single 16-bit R component.

Specifies a one-component, 16-bit signed floating-point format that has a single 16-bit R component.

Specifies a two-component, 32-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

Specifies a two-component, 32-bit signed normalized format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

Specifies a two-component, 32-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

Specifies a two-component, 32-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

Specifies a two-component, 32-bit unsigned integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

Specifies a two-component, 32-bit signed integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

Specifies a two-component, 32-bit signed floating-point format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

Specifies a three-component, 48-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

Specifies a three-component, 48-bit signed normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

Specifies a three-component, 48-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

Specifies a three-component, 48-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

Specifies a three-component, 48-bit unsigned integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

Specifies a three-component, 48-bit signed integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

Specifies a three-component, 48-bit signed floating-point format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

Specifies a four-component, 64-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

Specifies a four-component, 64-bit signed normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

Specifies a four-component, 64-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

Specifies a four-component, 64-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

Specifies a four-component, 64-bit unsigned integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

Specifies a four-component, 64-bit signed integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

Specifies a four-component, 64-bit signed floating-point format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

Specifies a one-component, 32-bit unsigned integer format that has a single 32-bit R component.

Specifies a one-component, 32-bit signed integer format that has a single 32-bit R component.

Specifies a one-component, 32-bit signed floating-point format that has a single 32-bit R component.

Specifies a two-component, 64-bit unsigned integer format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.

Specifies a two-component, 64-bit signed integer format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.

Specifies a two-component, 64-bit signed floating-point format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.

Specifies a three-component, 96-bit unsigned integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.

Specifies a three-component, 96-bit signed integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.

Specifies a three-component, 96-bit signed floating-point format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.

Specifies a four-component, 128-bit unsigned integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.

Specifies a four-component, 128-bit signed integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.

Specifies a four-component, 128-bit signed floating-point format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.

Specifies a one-component, 64-bit unsigned integer format that has a single 64-bit R component.

Specifies a one-component, 64-bit signed integer format that has a single 64-bit R component.

Specifies a one-component, 64-bit signed floating-point format that has a single 64-bit R component.

Specifies a two-component, 128-bit unsigned integer format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.

Specifies a two-component, 128-bit signed integer format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.

Specifies a two-component, 128-bit signed floating-point format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.

Specifies a three-component, 192-bit unsigned integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.

Specifies a three-component, 192-bit signed integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.

Specifies a three-component, 192-bit signed floating-point format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.

Specifies a four-component, 256-bit unsigned integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.

Specifies a four-component, 256-bit signed integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.

Specifies a four-component, 256-bit signed floating-point format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.

Specifies a three-component, 32-bit packed unsigned floating-point format that has a 10-bit B component in bits 22..31, an 11-bit G component in bits 11..21, an 11-bit R component in bits 0..10. See "fundamentals-fp10" and "fundamentals-fp11".

Specifies a three-component, 32-bit packed unsigned floating-point format that has a 5-bit shared exponent in bits 27..31, a 9-bit B component mantissa in bits 18..26, a 9-bit G component mantissa in bits 9..17, and a 9-bit R component mantissa in bits 0..8.

Specifies a one-component, 16-bit unsigned normalized format that has a single 16-bit depth component.

Specifies a two-component, 32-bit format that has 24 unsigned normalized bits in the depth component and, optionally:, 8 bits that are unused.

Specifies a one-component, 32-bit signed floating-point format that has 32-bits in the depth component.

Specifies a one-component, 8-bit unsigned integer format that has 8-bits in the stencil component.

Specifies a two-component, 24-bit format that has 16 unsigned normalized bits in the depth component and 8 unsigned integer bits in the stencil component.

Specifies a two-component, 32-bit packed format that has 8 unsigned integer bits in the stencil component, and 24 unsigned normalized bits in the depth component.

Specifies a two-component format that has 32 signed float bits in the depth component and 8 unsigned integer bits in the stencil component. There are optionally: 24-bits that are unused.

Specifies a three-component, block-compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data. This format has no alpha and is considered opaque.

Specifies a three-component, block-compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding. This format has no alpha and is considered opaque.

Specifies a four-component, block-compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data, and provides 1 bit of alpha.

Specifies a four-component, block-compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding, and provides 1 bit of alpha.

Specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.

Specifies a one-component, block-compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized red texel data.

Specifies a one-component, block-compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of signed normalized red texel data.

Specifies a two-component, block-compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

Specifies a two-component, block-compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of signed normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

Specifies a three-component, block-compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned floating-point RGB texel data.

Specifies a three-component, block-compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of signed floating-point RGB texel data.

Specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a three-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data. This format has no alpha and is considered opaque.

Specifies a three-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding. This format has no alpha and is considered opaque.

Specifies a four-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data, and provides 1 bit of alpha.

Specifies a four-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding, and provides 1 bit of alpha.

Specifies a four-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.

Specifies a four-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values with sRGB nonlinear encoding applied.

Specifies a one-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized red texel data.

Specifies a one-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4x4 rectangle of signed normalized red texel data.

Specifies a two-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

Specifies a two-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of signed normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5x4 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5x4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5x5 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5x5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6x5 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6x5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6x6 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6x6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8x5 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8x5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8x6 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8x6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8x8 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8x8 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x5 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x6 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x8 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x8 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x10 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10x10 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12x10 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12x10 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12x12 rectangle of unsigned normalized RGBA texel data.

Specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12x12 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

Opaque handle to a framebuffer object. Render passes operate in conjunction with framebuffers. Framebuffers represent a collection of specific memory attachments that a render pass instance uses.

Gets the parent of the resource.

Gets the render pass the framebuffer is compatible with.

Destroy a framebuffer object.

Structure specifying parameters of a newly created framebuffer. Image subresources used as attachments must not be used via any non-attachment usage for the duration of a render pass instance. This restriction means that the render pass has full knowledge of all uses of all of the attachments, so that the implementation is able to make correct decisions about when and how to perform layout transitions, when to overlap execution of subpasses, etc. It is legal for a subpass to use no color or depth/stencil attachments, and rather use shader side effects such as image stores and atomics to produce an output. In this case, the subpass continues to use the width, height, and layers of the framebuffer to define the dimensions of the rendering area, and the rasterizationSamples from each pipeline’s to define the number of samples used in rasterization; however, if is false, then all pipelines to be bound with a given zero-attachment subpass must have the same value for .

An array of handles, each of which will be used as the corresponding attachment in a render pass instance.

Dimension of the framebuffer. Must be less than or equal to .

Initializes a new instance of the structure.

An array of handles, each of which will be used as the corresponding attachment in a render pass instance. Dimension of the framebuffer. Dimension of the framebuffer. Dimension of the framebuffer.

Provides Google specific extension methods for the class.

Obtain the RC duration of the PE's display.

The swapchain to obtain the refresh duration for. An instance of the structure. Vulkan returns an error code.

Obtain timing of a previously-presented image. The implementation will maintain a limited amount of history of timing information about previous presents. Because of the asynchronous nature of the presentation engine, the timing information for a given command will become available some time later. These time values can be asynchronously queried, and will be returned if available. All time values are in nanoseconds, relative to a monotonically-increasing clock (e.g. `CLOCK_MONOTONIC` (see clock_gettime(2)) on Android and Linux).

The swapchain to obtain presentation timing information duration for. An array of structures. Vulkan returns an error code.

Structure containing the RC duration of a display.

The number of nanoseconds from the start of one refresh cycle to the next.

Structure containing timing information about a previously-presented image.

An application-provided value that was given to a previous command via (see below). It can be used to uniquely identify a previous present with the flink:vkQueuePresentKHR command.

An application-provided value that was given to a previous command via . If non-zero, it was used by the application to indicate that an image not be presented any sooner than .

The time when the image of the swapchain was actually displayed.

The time when the image of the swapchain could have been displayed. This may differ from if the application requested that the image be presented no sooner than .

An indication of how early the command was processed compared to how soon it needed to be processed, and still be presented at .

The earliest time each image should be presented.

The type of this structure.

Is or a pointer to an extension-specific structure.

The number of swapchains being presented to by this command.

Is null or a pointer to an array of elements with entries. If not null, each element of contains the earliest time to present the image corresponding to the entry in the array.

The earliest time image should be presented.

An application-provided identification value, that can be used with the results of , in order to uniquely identify this present. In order to be useful to the application, it should be unique within some period of time that is meaningful to the application.

Indicates that the image given should not be displayed to the user any earlier than this time. is a time in nanoseconds, relative to a monotonically-increasing clock (e.g. `CLOCKMONOTONIC` (see ClockGettime(2)) on Android and Linux). A value of zero indicates that the presentation engine may display the image at any time. This is useful when the application desires to provide presentID, but doesn't need a specific .

Handle to an unmanaged Vulkan resource.

Handle type.

Gets the handle to the unmanaged Vulkan resource.

Implicitly converts an instance of to its handle type.

Instance to convert.

that implements dispose pattern as described in https://msdn.microsoft.com/en-us/library/b1yfkh5e%28v=vs.110%29.aspx and stores an allocator.

Handle type.

Allows the object to free unmanaged resources before it is reclaimed by garbage collection.

Gets the memory allocator for the resource. This may be null.

Gets if the instance is disposed.

Performs application-defined tasks associated with freeing, releasing, or resetting resources.

Provides extensions methods for the class.

Creates an array of pointers from the sequence of types.

A sequence to create an array from. An array that contains the pointers to the input handles.

Creates an array of pointers from the sequence of types.

A sequence to create an array from. An array that contains the pointers to the input handles.

Opaque handle to a image object. Images represent multidimensional - up to 3 - arrays of data which can be used for various purposes (e.g. attachments, textures), by binding them to a graphics or compute pipeline via descriptor sets, or by directly specifying them as parameters to certain commands.

Gets the parent of the resource.

Bind device memory to an image object.

The object describing the device memory to attach. The start offset of the region of memory which is to be bound to the image. The number of bytes returned in the member in memory, starting from bytes, will be bound to the specified image. Vulkan returns an error code.

Returns the memory requirements for the image.

Memory requirements of the image object.

Retrieve information about an image subresource.

Subresource layout of an image.

Create an image view from an existing image.

The structure containing parameters to be used to create the image view. Controls host memory allocation. Vulkan returns an error code.

Query the memory requirements for a sparse image. If the image was not created with then the result will be empty.

Memory requirements for a sparse image.

Destroy an image object.

Structure specifying the parameters of a newly created image object.

Is or a pointer to an extension-specific structure.

Bitmask describing additional parameters of the image.

Specifies the basic dimensionality of the image. Layers in array textures do not count as a dimension for the purposes of the image type.

Describes the format and type of the data elements that will be contained in the image.

Describes the number of data elements in each dimension of the base level. The width, height, and depth members of extent must all be greater than 0.

Describes the number of levels of detail available for minified sampling of the image.

The number of layers in the image.

The number of sub-data element samples in the image.

Specifies the tiling arrangement of the data elements in memory.

A bitmask describing the intended usage of the image.

Specifies the sharing mode of the image when it will be accessed by multiple queue families.

A list of queue families that will access this image (ignored if is not ).

Specifies the initial of all image subresources of the image.

Bitmask specifying additional parameters of an image.

No flags.

Specifies that the image will be backed using sparse memory binding.

Specifies that the image can be partially backed using sparse memory binding. Images created with this flag must also be created with the flag.

Specifies that the image will be backed using sparse memory binding with memory ranges that might also simultaneously be backing another image (or another portion of the same image). Images created with this flag must also be created with the flag.

Specifies that the image can be used to create an with a different format from the image.

Specifies that the image can be used to create an of type or .

Specifies that the image can be used to create a of type or .

Specifies that the image can be used with a non-zero length of the member passed into . This flag also has the effect of making the image use the standard sparse image block dimensions.

Specifies the type of an image object.

Specify a one-dimensional image.

Specify a two-dimensional image.

Specify a three-dimensional image.

Bitmask specifying intended usage of an image.

Specifies that the image can be used as the source of a transfer command.

Specifies that the image can be used as the destination of a transfer command.

Specifies that the image can be used to create a suitable for occupying a slot either of type or , and be sampled by a shader.

Specifies that the image can be used to create a suitable for occupying a slot of type .

Specifies that the image can be used to create a suitable for use as a color or resolve attachment in a .

Specifies that the image can be used to create a suitable for use as a depth/stencil attachment in a .

Specifies that the memory bound to this image will have been allocated with the . This bit can be set for any image that can be used to create a suitable for use as a color, resolve, depth/stencil, or input attachment.

Specifies that the image can be used to create a suitable for occupying slot of type ; be read from a shader as an input attachment; and be used as an input attachment in a framebuffer.

Layout of image and image subresources.

Supports all types of device access.

Must only be used as a color or resolve attachment in a . This layout is valid only for image subresources of images created with the usage bit enabled.

Must only be used as a depth/stencil attachment in a . This layout is valid only for image subresources of images created with the usage bit enabled.

Must only be used as a read-only depth/stencil attachment in a and/or as a read-only image in a shader (which can be read as a sampled image, combined image/sampler and/or input attachment). This layout is valid only for image subresources of images created with the usage bit enabled. Only image subresources of images created with can be used as sampled image or combined image/sampler in a shader. Similarly, only image subresources of images created with can be used as input attachments.

Must only be used as a read-only image in a shader (which can be read as a sampled image, combined image/sampler and/or input attachment). This layout is valid only for image subresources of images created with the or usage bit enabled.

Must only be used as a source image of a transfer command (see the definition of . This layout is valid only for image subresources of images created with the usage bit enabled.

Must only be used as a destination image of a transfer command. This layout is valid only for image subresources of images created with the usage bit enabled.

Does not support device access. This layout must only be used as the or member, or as the old layout in an image transition. When transitioning out of this layout, the contents of the memory are preserved. This layout is intended to be used as the initial layout for an image whose contents are written by the host, and hence the data can be written to memory immediately, without first executing a layout transition. Currently, is only useful with images because there is not a standard layout defined for images.

Must only be used for presenting a swapchain image for display. A swapchain's image must be transitioned to this layout before calling , and must be transitioned away from this layout after calling .

Is valid only for shared presentable images, and must be used for any usage the image supports.

Structure specifying an attachment description.

A bitmask specifying additional properties of the attachment.

Specifies the format of the image that will be used for the attachment.

The number of samples of the image.

Specifies how the contents of color and depth components of the attachment are treated at the beginning of the subpass where it is first used.

Specifies how the contents of color and depth components of the attachment are treated at the end of the subpass where it is last used.

Specifies how the contents of stencil components of the attachment are treated at the beginning of the subpass where it is first used, and must be one of the same values allowed for above.

Specifies how the contents of stencil components of the attachment are treated at the end of the last subpass where it is used, and must be one of the same values allowed for above.

The layout the attachment image subresource will be in when a render pass instance begins.

The layout the attachment image subresource will be transitioned to when a render pass instance ends. During a render pass instance, an attachment can use a different layout in each subpass, if desired.

Bitmask specifying additional properties of an attachment.

Specifies that the attachment aliases the same device memory as other attachments.

Specify how contents of an attachment are treated at the beginning of a subpass.

Specifies that the previous contents of the image within the render area will be preserved. For attachments with a depth/stencil format, this uses the access type . For attachments with a color format, this uses the access type .

Specifies that the contents within the render area will be cleared to a uniform value, which is specified when a render pass instance is begun. For attachments with a depth/stencil format, this uses the access type . For attachments with a color format, this uses the access type .

Specifies that the previous contents within the area need not be preserved; the contents of the attachment will be undefined inside the render area. For attachments with a depth/stencil format, this uses the access type . For attachments with a color format, this uses the access type .

Specify how contents of an attachment are treated at the end of a subpass.

Specifies the contents generated during the render pass and within the render area are written to memory. For attachments with a depth/stencil format, this uses the access type . For attachments with a color format, this uses the access type .

Specifies the contents within the render area are not needed after rendering, and may be discarded; the contents of the attachment will be undefined inside the render area. For attachments with a depth/stencil format, this uses the access type . For attachments with a color format, this uses the access type .

Structure specifying a image format properties.

Are the maximum image dimensions.

The maximum number of mipmap levels. Must either be equal to 1 (valid only if tiling is ) or be equal to `ceil(log2(max(width, height, depth))) + 1`. Width, height and depth are taken from the corresponding members of .

The maximum number of array layers. Must either be equal to 1 or be greater than or equal to the member. A value of 1 is valid only if tiling is or if type is .

A bitmask of specifying all the supported sample counts for this image.

An upper bound on the total image size in bytes, inclusive of all image subresources. Implementations may have an address space limit on total size of a resource, which is advertised by this property. Must be at least 2^31.

Structure specifying an image subresource.

An selecting the image aspect.

Selects the mipmap level.

Selects the array layer.

Initializes a new instance of structure.

An selecting the image aspect. Selects the mipmap level. Selects the array layer.

Structure specifying sparse image format properties.

A bitmask specifying which aspects of the image the properties apply to.

The width, height, and depth of the sparse image block in texels or compressed texel blocks.

A bitmask specifying additional information about the sparse resource.

Bitmask specifying additional information about a sparse image resource.

Specifies that the image uses a single mip tail region for all array layers.

Specifies that the first mip level whose dimensions are not integer multiples of the corresponding dimensions of the sparse image block begins the mip tail region.

Specifies that the image uses non-standard sparse image block dimensions, and the image granularity values do not match the standard sparse image block dimensions for the given pixel format.

Structure specifying sparse image memory requirements.

The sparse image format properties.

The first mip level at which image subresources are included in the mip tail region.

The memory size (in bytes) of the mip tail region. If contains , this is the size of the whole mip tail, otherwise this is the size of the mip tail of a single array layer. This value is guaranteed to be a multiple of the sparse block size in bytes.

The opaque memory offset used with to bind the mip tail region(s).

The offset stride between each array-layer's mip tail, if does not contain (otherwise the value is undefined).

Structure specifying subresource layout.

The byte offset from the start of the image where the image subresource begins.

The size in bytes of the image subresource. size includes any extra memory that is required based on .

Describes the number of bytes between each row of texels in an image.

Describes the number of bytes between each array layer of an image.

Describes the number of bytes between each slice of 3D image.

Bitmask specifying sample counts supported for an image used for storage operations.

Specifies an image with one sample per pixel.

Specifies an image with 2 samples per pixel.

Specifies an image with 4 samples per pixel.

Specifies an image with 8 samples per pixel.

Specifies an image with 16 samples per pixel.

Specifies an image with 32 samples per pixel.

Specifies an image with 64 samples per pixel.

Opaque handle to a image view object. Image objects are not directly accessed by pipeline shaders for reading or writing image data. Instead, image views representing contiguous ranges of the image subresources and containing additional metadata are used for that purpose. Views must be created on images of compatible types, and must represent a valid subset of image subresources.

Gets the parent of the resource.

Destroy an image view object.

Structure specifying parameters of a newly created image view.

Specifies the type of the image view.

A describing the format and type used to interpret data elements in the image.

Specifies a remapping of color components (or of depth or stencil components after they have been converted into color components).

A range selecting the set of mipmap levels and array layers to be accessible to the view. Must be a valid image subresource range for image. If image was created with the flag, format must be compatible with the format used to create image. If image was not created with the flag, format must be identical to the format used to create image. If image is non-sparse then it must be bound completely and contiguously to a single object.

Initializes a new instance of the structure.

A describing the format and type used to interpret data elements in the image. A range selecting the set of mipmap levels and array layers to be accessible to the view. Specifies the type of the image view. Specifies a remapping of color components (or of depth or stencil components after they have been converted into color components).

Image view types.

Structure specifying a color component mapping.

Specifies the component value placed in the R component of the output vector.

Specifies the component value placed in the G component of the output vector.

Specifies the component value placed in the B component of the output vector.

Specifies the component value placed in the A component of the output vector.

Initializes a new instance of the structure.

Specifies the component value placed in the R component of the output vector. Specifies the component value placed in the G component of the output vector. Specifies the component value placed in the B component of the output vector. Specifies the component value placed in the A component of the output vector.

Specify how a component is swizzled.

Specifies that the component is set to the identity swizzle.

Specifies that the component is set to zero.

Specifies that the component is set to either 1 or 1.0, depending on whether the type of the image view format is integer or floating-point respectively.

Specifies that the component is set to the value of the R component of the image.

Specifies that the component is set to the value of the G component of the image.

Specifies that the component is set to the value of the B component of the image.

Specifies that the component is set to the value of the A component of the image.

Structure specifying a image subresource range.

A bitmask specifying which aspect(s) of the image are included in the view.

The first mipmap level accessible to the view.

The number of mipmap levels (starting from ) accessible to the view.

The first array layer accessible to the view.

The number of array layers (starting from ) accessible to the view.

Initializes a new instance of the structure.

A bitmask specifying which aspect(s) of the image are included in the view. The first mipmap level accessible to the view. The number of mipmap levels (starting from ) accessible to the view. The first array layer accessible to the view. The number of array layers (starting from ) accessible to the view.

Bitmask specifying which aspects of an image are included in a view.

Specifies the color aspect.

Specifies the depth aspect.

Specifies the stencil aspect.

Specifies the metadata aspect, used for sparse resource operations.

Opaque handle to an instance object. There is no global state in Vulkan and all per-application state is stored in an object. Creating an object initializes the Vulkan library and allows the application to pass information about itself to the implementation.

Create a new Vulkan instance.

An instance of controlling creation of the instance. Controls host memory allocation. Vulkan returns an error code.

Enumerates the physical devices accessible to a Vulkan instance.

A list of accessible physical devices. The result is never null. Vulkan returns an error code.

Return a function handle for a command or if not found. Vulkan commands are not necessarily exposed statically on a platform. Function pointers for all Vulkan commands can be obtained with this method.

The name of the command to obtain. Function handle for a command or if not found. is null.

Return a function delegate for a command or null if not found. Vulkan commands are not necessarily exposed statically on a platform. Function pointers for all Vulkan commands can be obtained with this method.

The name of the command to obtain. Function delegate for a command or null if not found. is null.

Returns global extension properties.

Is either null or a unicode string naming the layer to retrieve extensions from. When parameter is null, only extensions provided by the Vulkan implementation or by implicitly enabled layers are returned. Properties of available extensions for layer. Vulkan returns an error code.

Returns global layer properties.

Properties of available layers. Vulkan returns an error code.

Destroy an instance of Vulkan.

Structure specifying parameters of a newly created instance.

Is or a pointer to an extension-specific structure.

The information that helps implementations recognize behavior inherent to classes of applications.

Unicode strings containing the names of layers to enable for the created instance.

Unicode strings containing the names of extensions to enable.

Initializes a new instance of the structure.

The information that helps implementations recognize behavior inherent to classes of applications. Unicode strings containing the names of layers to enable for the created instance. Unicode strings containing the names of extensions to enable. Is or a pointer to an extension-specific structure.

Structure specifying application info.

The unicode string containing the name of the application.

The unsigned integer variable containing the developer-supplied version number of the application.

The unicode string containing the name of the engine (if any) used to create the application.

The unsigned integer variable containing the developer-supplied version number of the engine used to create the application.

The version of the Vulkan API against which the application expects to run. If is the implementation must ignore it, otherwise if the implementation does not support the requested it must return . The patch version number specified in is ignored when creating an instance object. Only the major and minor versions of the instance must match those requested in .

Initializes a new instance of the structure.

The unicode string containing the name of the application. The unsigned integer variable containing the developer-supplied version number of the application. The unicode string containing the name of the engine (if any) used to create the application. The unsigned integer variable containing the developer-supplied version number of the engine used to create the application. The version of the Vulkan API against which the application expects to run. If is the implementation must ignore it, otherwise if the implementation does not support the requested it must return . The patch version number specified in is ignored when creating an instance object. Only the major and minor versions of the instance must match those requested in .

Structure specifying a extension properties.

The name of the extension.

The version of this extension. It is an integer, incremented with backward compatible changes.

Returns a string that represents the current object.

A string that represents the current object.

Structure specifying layer properties.

A unicode string specifying the name of the layer. Use this name in the array to enable this layer for an instance.

The Vulkan version the layer was written to.

The version of this layer. It is an integer, increasing with backward compatible changes.

A unicode string providing additional details that can be used by the application to identify the layer.

Returns a string that represents the current object.

A string that represents the current object.

Utilities for interoping with the Vulkan C API.

Allocates memory from the unmanaged memory of the process.

The required number of bytes in memory. A pointer to the newly allocated memory. This memory must be released using the method.

Allocates memory from the unmanaged memory of the process.

Type to allocate for. The number of instances of to allocate for. A pointer to the newly allocated memory. This memory must be released using the method.

Resizes a block of memory previously allocated with .

A pointer to memory allocated with . The new size of the allocated block. A pointer to the reallocated memory. This memory must be released using .

Frees memory previously allocated from the unmanaged memory of the process.

The handle to free memory from.

Frees memory previously allocated from the unmanaged memory of the process.

The handle to free memory from.

Frees memory previously allocated from the unmanaged memory of the process. Both the handle as well as the handles pointed by the handle are freed.

A handle to handles to free memory from. Number of handles to free.

Converts an unmanaged function pointer to a delegate of a specified type.

The type of the delegate to return. The unmanaged function pointer to convert. An instance of the specified delegate type.

Converts a delegate of a specified type to a function pointer that is callable from unmanaged code.

The delegate to be passed to unmanaged code. The type of delegate to convert. A value that can be passed to unmanaged code, which, in turn, can use it to call the underlying managed delegate.

Copies a value of type to the given location.

The type of value to copy. A pointer to the value to copy. The location to copy to.

Copies values of type to the given location.

The type of values to copy. A pointer to the value to copy. The location to copy to.

Copies a value of type to the given location.

The type of value to copy. The location to copy to. A reference to the value to copy.

Copies values of type to the given location.

The type of values to copy. The location to copy to. A reference to the values to copy.

Returns the size of an object of the given type parameter.

The type of object whose size is retrieved. The size of an object of type .

Casts the gived object to the specified type.

The type which the object will be cast to. The object to cast. The original object, casted to the given type.

Utilities for interoping with strings.

Decodes specified null-terminated UTF-8 bytes into string.

Pointer to decode from. A string that contains the results of decoding the specified sequence of bytes.

Decodes specified null-terminated UTF-8 bytes into string.

Pointer to decode from. A string that contains the results of decoding the specified sequence of bytes.

Encodes a string as null-terminated UTF-8 bytes and stores into specified pointer.

The string to encode. Pointer to store encoded bytes. The maximum number of bytes the string can occupy found by .

Encodes a string as null-terminated UTF-8 bytes and allocates to unmanaged memory.

The string to encode. A pointer to the newly allocated memory. This memory must be released using the method.

Encodes strings as null-terminated UTF-8 byte sequences and allocates sequences as well as pointers to unmanaged memory.

Strings to encode. A pointer to the newly allocated memory. This memory must be released using the method.

Calculates the maximum number of bytes produced by encoding the specified number of UTF-8 characters.

The string to get byte count for. The maximum number of bytes produced by encoding the specified number of characters.

Utilities for interoping with structs.

Allocates unmanaged memory and copies the specified structure over.

Type of structure to copy. The value to copy. A pointer to the newly allocated memory. This memory must be released using the method.

Allocates unmanaged memory and copies the specified structure over. If the value is null, returns .

Type of structure to copy. The value to copy. A pointer to the newly allocated memory. This memory must be released using the method.

Allocates unmanaged memory and copies the specified structures over. If the array is null or empty, returns .

Type of elements to copy. The values to copy. A pointer to the newly allocated memory. This memory must be released using the method.

Gets a per-thread unique id to distuingish the static instance of . Useful when tracking unmanaged memory.

Occurs when unmanaged memory is allocated in Debug mode.

Occurs when unmanaged memory is freed in Debug mode.

Provides Khronos specific extension methods for the class.

Pushes descriptor updates into a command buffer.

The command buffer that the descriptors will be recorded in. Indicates whether the descriptors will be used by graphics pipelines or compute pipelines. There is a separate set of push descriptor bindings for each of graphics and compute, so binding one does not disturb the other. The object used to program the bindings. The set number of the descriptor set in the pipeline layout that will be updated. Structures describing the descriptors to be updated.

Pushes descriptor updates into a command buffer using a descriptor update template.

The command buffer that the descriptors will be recorded in. A descriptor update template which defines how to interpret the descriptor information in . The object used to program the bindings. It must be compatible with the layout used to create the handle. The set number of the descriptor set in the pipeline layout that will be updated. This must be the same number used to create the handle. Points to memory which contains the descriptors for the templated update.

Structure specifying values for Direct3D 12 fence-backed semaphores.

The type of this structure.

Is or a pointer to an extension-specific structure.

The number of semaphore wait values specified in .

Values for the corresponding semaphores in to wait for.

The number of semaphore signal values specified in .

Values for the corresponding semaphores in to set when signaled.

Initializes a new instance of the structure.

Values for the corresponding semaphores in to wait for. Values for the corresponding semaphores in to set when signaled. Is or a pointer to an extension-specific structure.

Provides Khronos specific extension methods for the class.

Trim a command pool. Trimming a command pool recycles unused memory from the command pool back to the system. Command buffers allocated from the pool are not affected by the command.

The command pool to trim.

Provides Khronos specific extension methods for the class.

Update the contents of a descriptor set object using an update template.

The descriptor set to update. Specifies the update mapping between the application pointer and the descriptor set to update. A pointer to memory which contains one or more structures of , , or used to write the descriptors.

Opaque handle to a descriptor update template. A descriptor update template specifies a mapping from descriptor update information in host memory to descriptors in a descriptor set. It is designed to avoid passing redundant information to the driver when frequently updating the same set of descriptors in descriptor sets.

Gets the parent of the resource.

Destroy a descriptor update template object.

Structure specifying parameters of a newly created descriptor update template.

Structures describing the descriptors to be updated by the descriptor update template.

Specifies the type of the descriptor update template. If set to it can only be used to update descriptor sets with a fixed . If set to it can only be used to push descriptor sets using the provided , , and number.

The the parameter update template will be used with. All descriptor sets which are going to be updated through the newly created descriptor update template must be created with this layout. is the descriptor set layout used to build the descriptor update template. All descriptor sets which are going to be updated through the newly created descriptor update template must be created with a layout that matches (is the same as, or defined identically to) this layout. This parameter is ignored if is not .

Indicates whether the descriptors will be used by graphics pipelines or compute pipelines.

The object used to program the bindings.

The set number of the descriptor set in the pipeline layout that will be updated.

Describes a single descriptor update of the descriptor update template.

Must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors.

And descriptorCount must be less than or equal to the number of array elements in the descriptor set binding implicitly specified when using a descriptor update template to update descriptors, and all applicable consecutive bindings.

The number of descriptors to update. If descriptorCount is greater than the number of remaining array elements in the destination binding, those affect consecutive bindings in a manner similar to above.

Specifies the type of the descriptor.

The offset in bytes of the first binding in the raw data structure.

The stride in bytes between two consecutive array elements of the descriptor update informations in the raw data structure. The stride is useful in case the bindings are stored in structs along with other data.

Indicates the valid usage of the descriptor update template.

Specifies that the descriptor update template will be used for descriptor set updates only.

Specifies that the descriptor update template will be used for push descriptor updates only.

Provides Khronos specific extension methods for the class.

Create a swapchain.

The device to create the swapchain for. The structure specifying the parameters of the created swapchain. The allocator used for host memory allocated for the swapchain object when there is no more specific allocator available. Created swapchain object. Vulkan returns an error code.

Create multiple swapchains that share presentable images. Is similar to , except that it takes an array of structures, and returns an array of swapchain objects. The swapchain creation parameters that affect the properties and number of presentable images must match between all the swapchains.If the displays used by any of the swapchains do not use the same presentable image layout or are incompatible in a way that prevents sharing images, swapchain creation will fail with the result code . If any error occurs, no swapchains will be created. Images presented to multiple swapchains must be re-acquired from all of them before transitioning away from . After destroying one or more of the swapchains, the remaining swapchains and the presentable images can continue to be used.

The device to create the swapchains for. Structures specifying the parameters of the created swapchains. The allocator used for host memory allocated for the swapchain objects when there is no more specific allocator available. The created swapchain objects. Vulkan returns an error code.

Create a new descriptor update template.

The logical device that creates the descriptor update template. Specifies the set of descriptors to update with a single call to . Controls host memory allocation. The resulting descriptor update template object. Vulkan returns an error code.

Get properties of external memory Win32 handles. Windows memory handles compatible with Vulkan may also be created by non-Vulkan APIs using methods beyond the scope of this specification.

The logical device that will be importing . The type of the handle . the handle which will be imported. Properties of . Vulkan returns an error code.

Get properties of external memory file descriptors. POSIX file descriptor memory handles compatible with Vulkan may also be created by non-Vulkan APIs using methods beyond the scope of this specification.

The logical device that will be importing . The type of the handle . The handle which will be imported. Properties of the handle . Vulkan returns an error code.

Import a semaphore from a Windows HANDLE.

The logical device that created the semaphore. Structure specifying the semaphore and import parameters. Vulkan returns an error code.

Import a semaphore from a POSIX file descriptor.

The logical device that created the semaphore. Structure specifying the semaphore and import parameters. Vulkan returns an error code.

Returns the memory requirements for specified Vulkan object.

The logical device that owns the buffer. Structure containing parameters required for the memory requirements query. Structure in which the memory requirements of the buffer object are returned.

Returns the memory requirements for specified Vulkan object.

The logical device that owns the image. Structure containing parameters required for the memory requirements query. Structure in which the memory requirements of the image object are returned.

Structure specifying Windows handle to import to a semaphore.

Is or a pointer to an extension-specific structure.

The semaphore into which the state will be imported.

Specifies additional parameters for the semaphore payload import operation.

Specifies the type of .

The external handle to import, or null.

A NULL-terminated UTF-16 string naming the underlying synchronization primitive to import, or null.

Structure specifying POSIX file descriptor to import to a semaphore.

Is or a pointer to an extension-specific structure.

The semaphore into which the payload will be imported.

Specifies additional parameters for the semaphore payload import operation.

Specifies the type of .

The external handle to import.

Bitmask of valid external semaphore handle types.

Specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls dup, dup2, close, and the non-standard system call dup3. Additionally, it must be transportable over a socket using an SCM_RIGHTS control message. It owns a reference to the underlying synchronization primitive represented by its Vulkan semaphore object.

Specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions DuplicateHandle, CloseHandle, CompareObjectHandles, GetHandleInformation, and SetHandleInformation. It owns a reference to the underlying synchronization primitive represented by its Vulkan semaphore object.

Specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own own a reference to the underlying synchronization primitive represented its Vulkan semaphore object, and will therefore become invalid when all Vulkan semaphore objects associated with it are destroyed.

Specifies an NT handle returned by ID3D12Device::CreateSharedHandle referring to a Direct3D 12 fence. It owns a reference to the underlying synchronization primitive associated with the Direct3D fence.

Specifies a POSIX file descriptor handle to a Linux or Android Fence object. It can be used with any native API accepting a valid fence object file descriptor as input. It owns a reference to the underlying synchronization primitive associated with the file descriptor. Implementations which support importing this handle type must accept any type of fence FD supported by the native system they are running on.

Properties of external memory windows handles.

Is or a pointer to an extension-specific structure.

A bitmask containing one bit set for every memory type which the specified windows handle can be imported as.

Properties of external memory file descriptors.

Is or a pointer to an extension-specific structure.

A bitmask containing one bit set for every memory type which the specified file descriptor can be imported as.

Type of this structure.

Is or a pointer to an extension-specific structure.

The to query.

Structure specifying memory requirements.

The type of this structure.

Is or a pointer to an extension-specific structure.

Describes the memory requirements of the resource.

The type of this structure.

Is or a pointer to an extension-specific structure.

The to query.

Pointer to next structure.

Provides Khronos specific extension methods for the class.

Get a Windows HANDLE for a memory object.

The memory object from which the handle will be exported. The type of handle requested. The Windows handle representing the underlying resources of the device memory object. Vulkan returns an error code.

Get a POSIX file descriptor for a memory object.

The memory object from which the handle will be exported. The type of handle requested. A file descriptor representing the underlying resources of the device memory object. Vulkan returns an error code.

Opaque handle to a display object.

Gets the parent of this resource.

Query display supported modes. Each display has one or more supported modes associated with it by default.

An array of structures. Vulkan returns an error code.

Opaque handle to a display mode object. There is currently no way to destroy "built in" modes.

Gets the parent of the resource.

Query capabilities of a mode and plane combination. Applications that wish to present directly to a display must select which layer, or "plane" of the display they wish to target, and a mode to use with the display. Each display supports at least one plane.

The plane which the application intends to use with the display, and is less than the number of display planes supported by the device. The structure in which the capabilities are returned.

Structure specifying parameters of a newly created display mode object.

A structure describing the display parameters to use in creating the new mode. If the parameters are not compatible with the specified display, the implementation must throw with .

Initializes a new instance of the structure.

A structure describing the display parameters to use in creating the new mode. If the parameters are not compatible with the specified display, the implementation must throw with .

Provides Khronos specific extension methods for the class.

Create a object for an Android native window.

The to associate with the surface. The structure containing the parameters affecting the creation of the surface object. The allocator used for host memory allocated for the surface object. The resulting surface object handle. Vulkan returns an error code.

Create a object for a Mir window.

Create a object for a Wayland window.

Create a object for a Win32 window.

Create a object for an X11 window, using the Xlib client-side library.

Create a structure representing a display plane and mode.

The to associate with the surface. The structure specifying which mode, plane, and other parameters to use. The allocator used for host memory allocated for the surface object. The resulting surface object handle. Vulkan returns an error code.

Create a object for a X11 window, using the XCB client-side library.

Provides Khronos specific extension methods for the class.

Query if presentation is supported.

The physical device. The queue family. The surface to query for. true if supported; otherwise false. Vulkan returns an error code.

Query surface capabilities.

The physical device that will be associated with the swapchain to be created, The surface that will be associated with the swapchain. A structure in which the capabilities are returned. Vulkan returns an error code.

Query color formats supported by surface.

A valid physical device. The surface to query. An array of valid surface formats. Vulkan returns an error code.

Query supported presentation modes.

The physical device that will be associated with the swapchain to be created. The surface that will be associated with the swapchain. An array of valid present modes. Vulkan returns an error code.

Query information about the available displays.

A valid physical device. An array of structures. Vulkan returns an error code.

Query the plane properties. Images are presented to individual planes on a display. Devices must support at least one plane on each display.Planes can be stacked and blended to composite multiple images on one display. Devices may support only a fixed stacking order and fixed mapping between planes and displays, or they may allow arbitrary application specified stacking orders and mappings between planes and displays.

A valid physical device. An array of structures. Vulkan returns an error code.

Get list of displays a plane supports.

A valid physical device. The plane which the application wishes to use. An array of display handles. Vulkan returns an error code.

Get the capabilities of a mode and plane combination.

The physical device associated with the display. The display mode the application intends to program when using the specified plane. The plane which the application intends to use with the display. A structure. Vulkan returns an error code.

Query physical device for presentation to Mir. Determines whether a queue family of a physical device supports presentation to the Mir compositor.

A physical device handle. Index to a queue family. A pointer to a MirConnection. true if the physical device supports presentation to the Mir compositor.

Query physical device for presentation to Wayland. Determines whether a queue family of a physical device supports presentation to the Wayland compositor.

A physical device handle. Index to a queue family. A pointer to a wl_display value. true if the physical device supports presentation to the Wayland compositor.

Query physical device for presentation to X11 server using XCB. Determines whether a queue family of a physical device supports presentation to an X11 server, using the XCB client-side library.

A physical device handle. Index to a queue family. Pointer to a xcb_connection_t value. An xcb_visualid_t. true if the physical device supports presentation to an X11 server.

Query physical device for presentation to Windows desktop. Determines whether a queue family of a physical device supports presentation to the Microsoft Windows desktop.

A physical device handle. Index to a queue family. true if the physical device supports presentation to The Windows desktop.

Query physical device for presentation to X11 server using Xlib. Determines whether a queue family of a physical device supports presentation to an X11 server, using the Xlib client-side library.

A physical device handle. Index to a queue family. Pointer to an Xlib Display. An X11 VisualID. true if the physical device supports presentation to an X11 server.

Reports capabilities of a physical device.

The physical device from which to query the supported features. A structure in which the physical device features are returned.

Returns properties of a physical device.

The handle to the physical device whose properties will be queried. The structure, that will be filled with returned information.

Lists physical device's format capabilities.

The physical device from which to query the format properties. The format whose properties are queried. The structure in which physical device properties for are returned.

Lists physical device's image format capabilities.

The physical device from which to query the image capabilities. A structure, describing the parameters that would be consumed by . A structure in which capabilities are returned. Vulkan returns an error code.

Reports properties of the queues of the specified physical device.

The handle to the physical device whose properties will be queried. An array of structures.

Reports memory information for the specified physical device.

The handle to the device to query. The structure in which the properties are returned.

Retrieve properties of an image format applied to sparse images. Each element will describe properties for one set of image aspects that are bound simultaneously in the image. This is usually one element for each aspect in the image, but for interleaved depth/stencil images there is only one element describing the combined aspects.

The physical device from which to query the sparse image capabilities. Contains input parameters to the command. An array of structures.

Reports capabilities of a surface on a physical device.

The physical device that will be associated with the swapchain to be created, as described for . Describes the surface and other fixed parameters that would be consumed by . A structure in which the capabilities are returned. Vulkan returns an error code.

Query color formats supported by surface.

The physical device that will be associated with the swapchain to be created, as described for . Describes the surface and other fixed parameters that would be consumed by . An array of structures. Vulkan returns an error code.

Query the external handle types supported by buffers.

The physical device from which to query the buffer capabilities. Structure, describing the parameters that would be consumed by . A structure in which capabilities are returned.

Function for querying external semaphore handle capabilities. Semaphores may support import and export of external semaphore handles.

The physical device from which to query the semaphore capabilities. Describes the parameters that would be consumed by . Structure in which capabilities are returned.

Structure describing capabilities of a surface.

The minimum number of images the specified device supports for a swapchain created for the surface, and will be at least one.

The current width and height of the surface, or the special value indicating that the surface size will be determined by the extent of a swapchain targeting the surface.

The maximum number of layers presentable images can have for a swapchain created for this device and surface, and will be at least one.

A bitmask of , indicating the presentation transforms supported for the surface on the specified device. At least one bit will be set.

Indicates the surface's current transform relative to the presentation engine's natural orientation.

A bitmask of , representing the alpha compositing modes supported by the presentation engine for the surface on the specified device, and at least one bit will be set. Opaque composition can be achieved in any alpha compositing mode by either using an image format that has no alpha component, or by ensuring that all pixels in the presentable images have an alpha value of 1.0.

Structure describing a supported swapchain format-color space pair. While the of a presentable image refers to the encoding of each pixel, the determines how the presentation engine interprets the pixel values.

A that is compatible with the specified surface.

A presentation that is compatible with the surface.

Structure describing an available display device.

A handle that is used to refer to the display described here. This handle will be valid for the lifetime of the Vulkan instance.

A unicode string containing the name of the display. Generally, this will be the name provided by the display's EDID. It can be null if no suitable name is available. If not null, the memory it points to must remain accessible as long as display is valid.

Describes the physical width and height of the visible portion of the display, in millimeters.

Describes the physical, native, or preferred resolution of the display.

Tells which transforms are supported by this display. This will contain one or more of the bits from .

Tells whether the planes on this display can have their z order changed. If this is true, the application can re-arrange the planes on this display in any order relative to each other.

Tells whether the display supports self-refresh/internal buffering. If this is true, the application can submit persistent present operations on swapchains created against this display.

Structure describing display plane properties.

The handle of the display the plane is currently associated with. If the plane is not currently attached to any displays, this will be .

The current z-order of the plane. This will be between 0 and the count of the elements returned by .

Structure describing display parameters associated with a display mode.

The 2D extents of the visible region.

The number of times the display is refreshed each second multiplied by 1000.

Structure describing display mode properties.

A handle to the display mode described in this structure. This handle will be valid for the lifetime of the Vulkan instance.

Is a structure describing the display parameters associated with displayMode.

Structure describing capabilities of a mode and plane combination.

A bitmask of describing the supported alpha blending modes.

Is the minimum source rectangle offset supported by this plane using the specified mode.

The maximum source rectangle offset supported by this plane using the specified mode. The x and y components of maxSrcPosition must each be greater than or equal to the x and y components of , respectively.

The minimum source rectangle size supported by this plane using the specified mode.

The maximum source rectangle size supported by this plane using the specified mode.

Has similar semantics to , but apply to the output region within the mode rather than the input region within the source image. Unlike , may contain negative values.

Has similar semantics to , but apply to the output region within the mode rather than the input region within the source image.

Structure describing the fine-grained features that can be supported by an implementation.

The type of this structure.

Is or a pointer to an extension-specific structure.

A structure describing the fine-grained features of the Vulkan 1.0 API.

Structure specifying physical device properties.

Is or a pointer to an extension-specific structure.

A structure describing the properties of the physical device. This structure is written with the same values as if it were written by .

Structure specifying image format properties.

The type of this structure.

Is or a pointer to an extension-specific structure.

A structure describing features supported by the requested format.

Structure specifying a image format properties.

The type of this structure.

Is or a pointer to an extension-specific structure. The chain is used to allow the specification of additional capabilities to be returned from .

A structure in which capabilities are returned.

Structure specifying image creation parameters.

The type of this structure.

Is or a pointer to an extension-specific structure. The chain is used to provide additional image parameters to .

The image format, corresponding to .

The image type, corresponding to .

The image tiling, corresponding to .

The intended usage of the image, corresponding to .

A bitmask describing additional parameters of the image, corresponding to .

Structure providing information about a queue family.

The type of this structure.

Is or a pointer to an extension-specific structure.

A structure which is populated with the same values as in .

Structure specifying physical device memory properties.

Is or a pointer to an extension-specific structure.

A structure which is populated with the same values as in .

Structure specifying sparse image format properties.

The type of this structure.

Is or a pointer to an extension-specific structure.

A structure which is populated with the same values as in .

Structure specifying sparse image format inputs.

The type of this structure.

Is or a pointer to an extension-specific structure.

The image format.

The dimensionality of image.

The number of samples per pixel as defined in .

A bitmask describing the intended usage of the image.

The tiling arrangement of the data elements in memory.

Structure describing capabilities of a surface.

The type of this structure.

Is or a pointer to an extension-specific structure.

Supported minimum number of images for the surface.

Supported maximum number of images for the surface, 0 for unlimited.

Current image width and height for the surface, (0, 0) if undefined.

Supported minimum image width and height for the surface.

Supported maximum image width and height for the surface.

Supported maximum number of image layers for the surface.

1 or more bits representing the transforms supported.

The surface's current transform relative to the device's natural orientation.

1 or more bits representing the alpha compositing modes supported.

Supported image usage flags for the surface.

Must not include unless the surface queried is a display surface.

Structure describing push descriptor limits that can be supported by an implementation.

The type of this structure.

Pointer to next structure.

The maximum number of descriptors that can be used in a descriptor set created with set.

Initializes a new instance of the structure.

The maximum number of descriptors that can be used in a descriptor set created with set. Pointer to next structure.

Structure specifying a surface and related swapchain creation parameters.

The type of this structure.

Is or a pointer to an extension-specific structure.

The that will be associated with the swapchain.

Initializes a new instance of the structure.

The that will be associated with the swapchain. Is or a pointer to an extension-specific structure.

Structure describing capabilities of a surface.

The type of this structure.

Is or a pointer to an extension-specific structure.

Describes the capabilities of the specified surface.

Initializes a new instance of the structure.

Describes the capabilities of the specified surface. Is or a pointer to an extension-specific structure.

Structure describing a supported swapchain format tuple.

The type of this structure.

Is or a pointer to an extension-specific structure.

Describes a format-color space pair that is compatible with the specified surface.

Initializes a new instance of the structure.

Describes a format-color space pair that is compatible with the specified surface. Is or a pointer to an extension-specific structure.

Structure describing capabilities of a surface for shared presentation.

The type of this structure.

Is or a pointer to an extension-specific structure.

A bitmask representing the ways the application can use the shared presentable image from a swapchain created with set to or for the surface on the specified device. must be included in the set but implementations may support additional usages.

Initializes a new instance of the structure.

Structure specifying external image creation parameters.

The type of this structure.

Is or a pointer to an extension-specific structure.

A bit indicating a memory handle type that will be used with the memory associated with the image.

Initializes a new instance of the structure.

A bit indicating a memory handle type that will be used with the memory associated with the image. Is or a pointer to an extension-specific structure.

Structure specifying external memory handle type capabilities.

A bitmask describing the features of handle type.

A bitmask specifying handle types that can be used to import objects from which handle type can be exported.

A bitmask specifying handle types which can be specified at the same time as handle type when creating an image compatible with external memory.

Structure specifying supported external handle capabilities.

Is or a pointer to an extension-specific structure.

Specifies various capabilities of the external handle type when used with the specified buffer creation parameters.

Structure specifying buffer creation parameters.

Is or a pointer to an extension-specific structure.

A bitmask describing additional parameters of the buffer, corresponding to .

A bitmask describing the intended usage of the buffer, corresponding to .

A bit indicating a memory handle type that will be used with the memory associated with the buffer.

Structure specifying supported external handle properties.

Is or a pointer to an extension-specific structure.

Specifies various capabilities of the external handle type when used with the specified image creation parameters.

Bitmask specifying external memory handle types.

Specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls dup, dup2, close, and the non-standard system call dup3. Additionally, it must be transportable over a socket using an SCM_RIGHTS control message. It owns a reference to the underlying memory resource represented by its Vulkan memory object.

Specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must: be compatible with the functions DuplicateHandle, CloseHandle, CompareObjectHandles, GetHandleInformation, and SetHandleInformation. It owns a reference to the underlying memory resource represented by its Vulkan memory object.

Specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own own a reference to the underlying memory resource represented its Vulkan memory object, and will therefore become invalid when all Vulkan memory objects associated with it are destroyed.

Specifies an NT handle returned by IDXGIResource1::CreateSharedHandle referring to a Direct3D 10 or 11 texture resource. It owns a reference to the memory used by the Direct3D resource.

Specifies a global share handle returned by IDXGIResource::GetSharedHandle referring to a Direct3D 10 or 11 texture resource. It does not own own a reference to the underlying Direct3D resource, and will therefore become invalid when all Vulkan memory objects and Direct3D resources associated with it are destroyed.

Specifies an NT handle returned by ID3D12Device::CreateSharedHandle referring to a Direct3D 12 heap resource. It owns a reference to the resources used by the Direct3D heap.

Specifies an NT handle returned by ID3D12Device::CreateSharedHandle referring to a Direct3D 12 committed resource. It owns a reference to the memory used by the Direct3D resource.

Bitmask specifying features of an external memory handle type.

Specifies that images or buffers created with the specified parameters and handle type must use the mechanisms defined in the "VK_NV_dedicated_allocation" extension to to create (or import) a dedicated allocation for the image or buffer.

Specifies that handles of this type can be exported from Vulkan memory objects.

Specifies that handles of this type can be imported as Vulkan memory objects.

Structure specifying semaphore creation parameters.

Is or a pointer to an extension-specific structure.

A bit indicating an external semaphore handle type for which capabilities will be returned.

Structure describing supported external semaphore handle features.

Pointer to next structure.

A bitmask specifying handle types that can be used to import objects from which handleType can be exported.

A bitmask specifying handle types which can be specified at the same time as handleType when creating a semaphore.

A bitmask describing the features of handle type.

Bitfield describing features of an external semaphore handle type.

Specifies that handles of this type can be exported from Vulkan semaphore objects.

Specifies that handles of this type can be imported as Vulkan semaphore objects.

Structure describing variable pointers features that can be supported by an implementation.

Pointer to next structure.

Bitmask specifying additional parameters of semaphore payload import.

Indicates that the semaphore payload will be imported only temporarily, regardless of the permanence of handleType.

Bitmask of valid external fence handle types.

Indicates a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls dup, dup2, close, and the non-standard system call dup3. Additionally, it must be transportable over a socket using an SCMRIGHTS control message. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.

Indicates an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions DuplicateHandle, CloseHandle, CompareObjectHandles, GetHandleInformation, and SetHandleInformation. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.

Indicates a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying synchronization primitive represented by its Vulkan fence object, and will therefore become invalid when all Vulkan fence objects associated with it are destroyed.

Indicates a POSIX file descriptor handle to a Linux Sync File or Android Fence. It can be used with any native API accepting a valid sync file or fence as input. It owns a reference to the underlying synchronization primitive associated with the file descriptor. Implementations which support importing this handle type must accept any type of sync or fence FD supported by the native system they are running on.

Bitfield describing features of an external fence handle type.

Indicates handles of this type can be exported from Vulkan fence objects.

Indicates handles of this type can be imported to Vulkan fence objects.

Bitmask specifying additional parameters of fence payload import.

Specifies that the fence payload will be imported only temporarily, regardless of the permanence of handle type.

Structure specifying IDs related to the physical device.

Is or a pointer to an extension-specific structure.

An array of size , containing 8-bit values that represent a universally unique identifier for the device.

An array of size , containing 8-bit values that represent a universally unique identifier for the driver build in use by the device.

A array of size , containing 8-bit values that represent a locally unique identifier for the device.

A bitfield identifying the node within a linked device adapter corresponding to the device.

A boolean value that will be true if contains a valid LUID, and false if it does not.

Specify that an image may be backed by external memory.

The type of this structure.

Is or a pointer to an extension-specific structure.

Specifies one or more external memory handle types.

Specify that a buffer may be backed by external memory.

The type of this structure.

Is or a pointer to an extension-specific structure.

Specifies one or more external memory handle types.

Specify exportable handle types for a device memory object.

The type of this structure.

Is or a pointer to an extension-specific structure.

Specifies one or more memory handle types the application can export from the resulting allocation. The application can request multiple handle types for the same allocation.

Import Win32 memory created on the same physical device.

The type of this structure.

Is or a pointer to an extension-specific structure.

Specifies the type of handle or name.

The external handle to import, or null.

A NULL-terminated UTF-16 string naming the underlying memory resource to import, or null.

Structure specifying additional attributes of Windows handles exported from a memory.

The type of this structure.

Is or a pointer to an extension-specific structure.

A pointer to a Windows SECURITY_ATTRIBUTES structure specifying security attributes of the handle.

A DWORD specifying access rights of the handle.

A NULL-terminated UTF-16 string to associate with the underlying resource referenced by NT handles exported from the created memory.

Structure describing a Win32 handle semaphore export operation.

The type of this structure.

Is or a pointer to an extension-specific structure.

The memory object from which the handle will be exported.

The type of handle requested.

Structure describing a POSIX FD semaphore export operation.

The type of this structure.

Is or a pointer to an extension-specific structure.

The memory object from which the handle will be exported.

The type of handle requested.

Structure specifying additional attributes of Windows handles exported from a semaphore.

The type of this structure.

Is or a pointer to an extension-specific structure.

A pointer to a Windows SECURITY_ATTRIBUTES structure specifying security attributes of the handle.

A DWORD specifying access rights of the handle.

A NULL-terminated UTF-16 string to associate with the underlying synchronization primitive referenced by NT handles exported from the created semaphore.

Structure describing a Win32 handle semaphore export operation.

The type of this structure.

Is or a pointer to an extension-specific structure.

The semaphore from which state will be exported.

The type of handle requested.

Structure describing a POSIX FD semaphore export operation.

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is the semaphore from which state will be exported.

Is the type of handle requested.

Structure specifying fence creation parameters.

Is the type of this structure.

Is NULL or a pointer to an extension-specific structure.

Is a value indicating an external fence handle type for which capabilities will be returned.

Structure describing supported external fence handle features.

Pointer to next structure.

Is a bitmask of indicating which types of imported handle handleType can be exported from.

Is a bitmask of specifying handle types which can be specified at the same time as handleType when creating a fence.

Is a bitmask of indicating the features of handleType.

Structure specifying handle types that can be exported from a fence.

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is a bitmask of specifying one or more fence handle types the application can export from the resulting fence. The application can request multiple handle types for the same fence.

(None).

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is the fence into which the state will be imported.

Is a bitmask of specifying additional parameters for the fence payload import operation.

Specifies the type of handle.

Is the external handle to import, or null.

Is the NULL-terminated UTF-16 string naming the underlying synchronization primitive to import, or null.

Structure specifying additional attributes of Windows handles exported from a fence.

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is a pointer to a Windows SECURITY_ATTRIBUTES structure specifying security attributes of the handle.

Is a xDWORD specifying access rights of the handle.

Is a NULL-terminated UTF-16 string to associate with the underlying synchronization primitive referenced by NT handles exported from the created fence.

Structure describing a Win32 handle fence export operation.

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is the fence from which state will be exported.

Is the type of handle requested.

(None).

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is the fence into which the payload will be imported.

Is a bitmask of specifying additional parameters for the fence payload import operation.

Specifies the type of fd.

Is the external handle to import.

Structure describing a POSIX FD fence export operation.

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is the fence from which state will be exported.

Is the type of handle requested.

Structure describing features supported by VKKHR16bitStorage.

Pointer to next structure.

16-bit integer/floating-point variables supported in BufferBlock.

16-bit integer/floating-point variables supported in BufferBlock and Block.

16-bit integer/floating-point variables supported in PushConstant.

16-bit integer/floating-point variables supported in shader inputs and outputs.

Structure describing dedicated allocation requirements of buffer and image resources.

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Indicates that the implementation would prefer a dedicated allocation for this resource. The application is still free to suballocate the resource but it may get better performance if a dedicated allocation is used.

Indicates that a dedicated allocation is required for this resource.

Specify a dedicated memory allocation resource.

Is the type of this structure.

Is or a pointer to an extension-specific structure.

Is 0 or a handle of an image which this memory will be bound to.

Is 0 or a handle of a buffer which this memory will be bound to.

Provides Khronos specific extension methods for the class.

Queue an image for presentation.

The queue that is capable of presentation to the target surface's platform on the same device as the image's swapchain. The structure specifying the parameters of the presentation. Vulkan returns an error code.

Queue an image for presentation.

The queue that is capable of presentation to the target surface's platform on the same device as the image's swapchain. Semaphore to wait for before presenting. Valid swapchain handle. Index into the array of swapchain's presentable images. Vulkan returns an error code.

Structure describing parameters of a queue presentation.

Is or a pointer to an extension-specific structure.

Semaphores to wait for before presenting.

Valid handles.

Indices into the array of each swapchain's presentable images, with swapchain count entries. Each entry in this array identifies the image to present on the corresponding entry in the array.

typed elements with swapchain count entries. Applications that do not need per-swapchain results can use null for . If not null, each entry in will be set to the for presenting the swapchain corresponding to the same index in .

Initializes a new instance of the structure.

Semaphores to wait for before presenting. Valid handles. Indices into the array of each swapchain’s presentable images, with swapchain count entries. Each entry in this array identifies the image to present on the corresponding entry in the array. typed elements with swapchain count entries. Applications that do not need per-swapchain results can use null for . If not null, each entry in will be set to the for presenting the swapchain corresponding to the same index in . Is or a pointer to an extension-specific structure.

Structure describing parameters of a queue presentation to a swapchain.

The type of this structure.

Is or a pointer to an extension-specific structure.

A rectangular region of pixels to present. It must be a subset of the image being presented. If is not specified, this region will be assumed to be the entire presentable image.

A rectangular region within the visible region of the swapchain's display mode. If is not specified, this region will be assumed to be the entire visible region of the visible region of the swapchain's mode. If the specified rectangle is a subset of the display mode's visible region, content from display planes below the swapchain's plane will be visible outside the rectangle. If there are no planes below the swapchain's, the area outside the specified rectangle will be black. If portions of the specified rectangle are outside of the display's visible region, pixels mapping only to those portions of the rectangle will be discarded.

If this is true, the display engine will enable buffered mode on displays that support it. This allows the display engine to stop sending content to the display until a new image is presented. The display will instead maintain a copy of the last presented image. This allows less power to be used, but may increase presentation latency. If is not specified, persistent mode will not be used.

Structure hint of rectangular regions changed by . When the "VK_KHR_incremental_present" extension is enabled, additional fields can be specified that allow an application to specify that only certain rectangular regions of the presentable images of a swapchain are changed. This is an optimization hint that a presentation engine may use to only update the region of a surface that is actually changing. The application still must ensure that all pixels of a presented image contain the desired values, in case the presentation engine ignores this hint. An application can provide this hint by including the structure in the chain.

The type of this structure.

Is or a pointer to an extension-specific structure.

The number of swapchains being presented to by this command.

Is null or a pointer to an array of elements with entries. If not null, each element of contains the region that has changed since the last present to the swapchain in the corresponding entry in the array.

Initializes a new instance of the structure.

The number of swapchains being presented to by this command. Is null or a pointer to an array of elements with entries. If not null, each element of contains the region that has changed since the last present to the swapchain in the corresponding entry in the array. Is or a pointer to an extension-specific structure.

Structure containing rectangular region changed by for a given .

The number of rectangles in , or zero if the entire image has changed and should be presented.

Is either null or a pointer to an array of structures. The structure is the framebuffer coordinates, plus layer, of a portion of a presentable image that has changed and must be presented. If non- null, each entry in is a rectangle of the given image that has changed since the last image was presented to the given swapchain.

Initializes a new instance of the structure.

The number of rectangles in , or zero if the entire image has changed and should be presented. Is either null or a pointer to an array of structures. The structure is the framebuffer coordinates, plus layer, of a portion of a presentable image that has changed and must be presented. If non- null, each entry in is a rectangle of the given image that has changed since the last image was presented to the given swapchain.

Structure containing a rectangle, including layer, changed by for a given .

The origin of the rectangle, in pixels.

The size of the rectangle, in pixels.

The layer of the image. For images with only one layer, the value of must be 0.

Initializes a new instance of the structure.

The origin of the rectangle, in pixels. The size of the rectangle, in pixels. The layer of the image. For images with only one layer, the value of must be 0.

Provides Khronos specific extension methods for the class.

Get a Windows HANDLE for a semaphore.

The semaphore from which state will be exported. The type of handle requested. The Windows handle representing the semaphore state. Vulkan returns an error code.

Get a POSIX file descriptor handle for a semaphore.

The semaphore from which state will be exported. The type of handle requested. The file descriptor representing the semaphore state. Vulkan returns an error code.

A object abstracts a native platform surface or window object for use with Vulkan. The extension declares the object, and provides a function for destroying objects. Separate platform-specific extensions each provide a function for creating a object for the respective platform. From the application’s perspective this is an opaque handle, just like the handles of other Vulkan objects.

Gets the parent of this resource.

Destroy a surface object.

Structure specifying parameters of a newly created Android surface object.

Pointer to the Android ANativeWindow to associate the surface with.

Initializes a new instance of structure.

Pointer to the Android ANativeWindow to associate the surface with.

Structure specifying parameters of a newly created Mir surface object.

Pointer to the MirConnection to associate the surface with.

Pointer to the MirSurface for the window to associate the surface with.

Initializes a new instance of structure.

Pointer to the MirConnection to associate the surface with. Pointer to the MirSurface for the window to associate the surface with.

Structure specifying parameters of a newly created Wayland surface object.

Wayland wl_display to associate the surface with.

Wayland wl_surface to associate the surface with.

Initializes a new instance of structure.

Wayland wl_display to associate the surface with. Wayland wl_surface to associate the surface with.

Structure specifying parameters of a newly created Win32 surface object.

Win32 HINSTANCE to associate the surface with.

Win32 HWND for the window to associate the surface with.

Initializes a new instance of the structure.

Win32 HINSTANCE to associate the surface with. Win32 HWND to associate the surface with.

Structure specifying parameters of a newly created Xlib surface object.

A pointer to an Xlib Display connection to the X server.

A pointer to an Xlib Window to associate the surface with.

Initializes a new instance of the structure.

A pointer to an Xlib Display connection to the X server. A pointer to an Xlib Window to associate the surface with.

Structure specifying parameters of a newly created display plane surface object.

A handle specifying the mode to use when displaying this surface.

The plane on which this surface appears.

The z-order of the plane.

Specifies the transform to apply to the images as part of the scanout operation.

The global alpha value. This value is ignored if is not .

Specifies the type of alpha blending to use.

The size of the presentable images to use with the surface.

Initializes a new instance of the structure.

A handle specifying the mode to use when displaying this surface. The plane on which this surface appears. The z-order of the plane. Specifies the transform to apply to the images as part of the scanout operation. The global alpha value. This value is ignored if is not . Specifies the type of alpha blending to use. Size of the images to use with this surface.

Alpha blending type.

No flags.

Specifies that the source image will be treated as opaque.

Specifies that a global alpha value must be specified that will be applied to all pixels in the source image.

Specifies that the alpha value will be determined by the alpha channel of the source image's pixels. If the source format contains no alpha values, no blending will be applied. The source alpha values are not premultiplied into the source image's other color channels.

Is equivalent to , except the source alpha values are assumed to be premultiplied into the source image's other color channels.

Structure specifying parameters of a newly created Xcb surface object.

A pointer to an xcb_connection_t to the X server.

The xcb_window_t for the X11 window to associate the surface with.

Initializes a new instance of the structure.

A pointer to an xcb_connection_t to the X server. The xcb_window_t for the X11 window to associate the surface with.

Opaque handle to a swapchain object. A swapchain object (a.k.a. swapchain) provides the ability to present rendering results to a surface. A swapchain is an abstraction for an array of presentable images that are associated with a surface. The swapchain images are represented by objects created by the platform. One image (which can be an array image for multiview/stereoscopic-3D surfaces) is displayed at a time, but multiple images can be queued for presentation. An application renders to the image, and then queues the image for presentation to the surface. A native window cannot be associated with more than one swapchain at a time. Further, swapchains cannot be created for native windows that have a non-Vulkan graphics API surface associated with them.

Gets the parent of this resource.

Gets the format.

Obtain the array of presentable images associated with a swapchain.

An array of objects. Vulkan returns an error code.

Retrieve the index of the next available presentable image.

Indicates how long the function waits, in nanoseconds, if no image is available. If timeout is 0, the command will not block, but will either succeed or throw with . If timeout is -1, the function will not return until an image is acquired from the presentation engine. Other values for timeout will cause the function to return when an image becomes available, or when the specified number of nanoseconds have passed (in which case it will return throw with ). An error can also cause the command to return early. null or a semaphore to signal. and must not both be equal to null. null or a fence to signal. and must not both be equal to null. The index of the next available presentable image. Vulkan returns an error code.

Get a swapchain's status. The possible return values should be interpreted as follows: * - Indicates the presentation engine is presenting the contents of the shared presentable image, as per the swapchain's * - The swapchain no longer matches the surface properties exactly, but the presentation engine is presenting the contents of the shared presentable image, as per the swapchain's * - The surface has changed in such a way that it is no longer compatible with the swapchain * - The surface is no longer available

Status of the swapchain.

Destroy a swapchain object.

Structure specifying parameters of a newly created swapchain object.

A bitmask indicating parameters of swapchain creation.

The that the swapchain will present images to.

The minimum number of presentable images that the application needs. The platform will either create the swapchain with at least that many images, or will fail to create the swapchain.

A format that is valid for swapchains on the specified surface.

Color space that is valid for swapchains on the specified surface.

The size (in pixels) of the swapchain. Behavior is platform-dependent when the image extent does not match the surface's as returned by .

The number of views in a multiview/stereo surface. For non-stereoscopic-3D applications, this value is 1.

A bitmask indicating how the application will use the swapchain's presentable images.

The sharing mode used for the images of the swapchain.

Queue family indices having access to the images of the swapchain in case is .

A bitmask describing the transform, relative to the presentation engine's natural orientation, applied to the image content prior to presentation. If it does not match the value returned by , the presentation engine will transform the image content as part of the presentation operation.

A bitmask indicating the alpha compositing mode to use when this surface is composited together with other surfaces on certain window systems.

The presentation mode the swapchain will use. A swapchain's present mode determines how incoming present requests will be processed and queued internally.

Indicates whether the Vulkan implementation is allowed to discard rendering operations that affect regions of the surface which are not visible. If set to true, the presentable images associated with the swapchain may not own all of their pixels. Pixels in the presentable images that correspond to regions of the target surface obscured by another window on the desktop or subject to some other clipping mechanism will have undefined content when read back. Pixel shaders may not execute for these pixels, and thus any side affects they would have had will not occur. If set to false, presentable images associated with the swapchain will own all the pixels they contain. Setting this value to true does not guarantee any clipping will occur, but allows more optimal presentation methods to be used on some platforms.

Existing swapchain to replace, if any.

Initializes a new instance of the structure.

The that the swapchain will present images to. The size (in pixels) of the swapchain. Behavior is platform-dependent when the image extent does not match the surface's as returned by . A bitmask describing the transform, relative to the presentation engine's natural orientation, applied to the image content prior to presentation. If it does not match the value returned by , the presentation engine will transform the image content as part of the presentation operation. A bitmask indicating how the application will use the swapchain's presentable images. A bitmask indicating parameters of swapchain creation. The minimum number of presentable images that the application needs. The platform will either create the swapchain with at least that many images, or will fail to create the swapchain. A format that is valid for swapchains on the specified surface. A bitmask indicating the alpha compositing mode to use when this surface is composited together with other surfaces on certain window systems. The number of views in a multiview/stereo surface. For non-stereoscopic-3D applications, this value is 1. The presentation mode the swapchain will use. A swapchain's present mode determines how incoming present requests will be processed and queued internally. Indicates whether the Vulkan implementation is allowed to discard rendering operations that affect regions of the surface which are not visible. Existing swapchain to replace, if any.

Bitmask controlling swapchain creation.

No flags.

Specifies that images created from the swapchain (i.e. with the swapchain member of set to this swapchain's handle) must use .

Supported color space of the presentation engine.

Indicates support for the sRGB color space.

Indicates support for the Display-P3 color space and applies an sRGB-like transfer function.

Indicates support for the extended sRGB color space and applies a linear transfer function.

Indicates support for the DCI-P3 color space and applies a linear OETF.

Indicates support for the DCI-P3 color space and applies the Gamma 2.6 OETF.

Indicates support for the BT709 color space and applies a linear OETF.

Indicates support for the BT709 color space and applies the SMPTE 170M OETF.

Indicates support for the BT2020 color space and applies a linear OETF.

Indicates support for HDR10 (BT2020 color) space and applies the SMPTE ST2084 Perceptual Quantizer (PQ) OETF.

Indicates support for Dolby Vision (BT2020 color space), proprietary encoding, and applies the SMPTE ST2084 OETF.

Indicates support for HDR10 (BT2020 color space) and applies the Hybrid Log Gamma (HLG) OETF.

Indicates support for the AdobeRGB color space and applies a linear OETF.

Indicates support for the AdobeRGB color space and applies the Gamma 2.2 OETF.

Indicates that color components are used "as is". This is intended to allow application to supply data for color spaces not described here.

Indicates support for the extended sRGB color space and applies an sRGB transfer function.

Presentation transforms supported on a device.

Indicates that image content is presented without being transformed.

Indicates that image content is rotated 90 degrees clockwise.

Indicates that image content is rotated 180 degrees clockwise.

Indicates that image content is rotated 270 degrees clockwise.

Indicates that image content is mirrored horizontally.

Indicates that image content is mirrored horizontally, then rotated 90 degrees clockwise.

Indicates that image content is mirrored horizontally, then rotated 180 degrees clockwise.

Indicates that image content is mirrored horizontally, then rotated 270 degrees clockwise.

Indicates that presentation transform is not specified, and is instead determined by platform-specific considerations and mechanisms outside Vulkan.

Alpha compositing modes supported on a device.

The alpha channel, if it exists, of the images is ignored in the compositing process. Instead, the image is treated as if it has a constant alpha of 1.0.

The alpha channel, if it exists, of the images is respected in the compositing process. The non-alpha channels of the image are expected to already be multiplied by the alpha channel by the application.

The alpha channel, if it exists, of the images is respected in the compositing process. The non-alpha channels of the image are not expected to already be multiplied by the alpha channel by the application; instead, the compositor will multiply the non-alpha channels of the image by the alpha channel during compositing.

The way in which the presentation engine treats the alpha channel in the images is unknown to the Vulkan API. Instead, the application is responsible for setting the composite alpha blending mode using native window system commands. If the application does not set the blending mode using native window system commands, then a platform-specific default will be used.

Presentation mode supported for a surface.

Indicates that the presentation engine does not wait for a vertical blanking period to update the current image, meaning this mode may result in visible tearing. No internal queuing of presentation requests is needed, as the requests are applied immediately.

Indicates that the presentation engine waits for the next vertical blanking period to update the current image. Tearing cannot be observed. An internal single-entry queue is used to hold pending presentation requests. If the queue is full when a new presentation request is received, the new request replaces the existing entry, and any images associated with the prior entry become available for re-use by the application. One request is removed from the queue and processed during each vertical blanking period in which the queue is non-empty.

Indicates that the presentation engine waits for the next vertical blanking period to update the current image. Tearing cannot be observed. An internal queue is used to hold pending presentation requests. New requests are appended to the end of the queue, and one request is removed from the beginning of the queue and processed during each vertical blanking period in which the queue is non-empty. This is the only value of presentMode that is required: to be supported.

Indicates that the presentation engine generally waits for the next vertical blanking period to update the current image. If a vertical blanking period has already passed since the last update of the current image then the presentation engine does not wait for another vertical blanking period for the update, meaning this mode may result in visible tearing in this case. This mode is useful for reducing visual stutter with an application that will mostly present a new image before the next vertical blanking period, but may occasionally be late, and present a new image just after the next vertical blanking period. An internal queue is used to hold pending presentation requests. New requests are appended to the end of the queue, and one request is removed from the beginning of the queue and processed during or after each vertical blanking period in which the queue is non-empty.

Indicates that the presentation engine and application have concurrent access to a single image, which is referred to as a shared presentable image. The presentation engine is only required to update the current image after a new presentation request is received. Therefore the application must make a presentation request whenever an update is required. However, the presentation engine may update the current image at any point, meaning this mode may result in visible tearing.

Indicates that the presentation engine and application have concurrent access to a single image, which is referred to as a shared presentable image. The presentation engine periodically updates the current image on its regular refresh cycle. The application is only required to make one initial presentation request, after which the presentation engine must update the current image without any need for further presentation requests. The application can indicate the image contents have been updated by making a presentation request, but this does not guarantee the timing of when it will be updated. This mode may result in visible tearing if rendering to the image is not timed correctly.

Provides experimental Khronos specific extension methods for the class.

Modify device mask of a command buffer.

Command buffer whose current device mask is modified. The new value of the current device mask.

Dispatch compute work items.

The command buffer into which the command will be recorded. The start value for the X component of WorkgroupId. The start value for the Y component of WorkgroupId. The start value for the Z component of WorkgroupId. The number of local workgroups to dispatch in the X dimension. The number of local workgroups to dispatch in the Y dimension. The number of local workgroups to dispatch in the Z dimension.

Set the initial device mask for a command buffer.

The type of this structure.

Is or a pointer to an extension-specific structure.

The initial value of the command buffer's device mask.

Initializes a new instance of the structure.

The initial value of the command buffer's device mask. Is or a pointer to an extension-specific structure.

Set the initial device mask and render areas for a render pass instance.

The type of this structure.

Is or a pointer to an extension-specific structure.

The device mask for the render pass instance.

The number of elements in the array.

Structures defining the render area for each physical device.

Initializes a new instance of the structure.

The device mask for the render pass instance. Structures defining the render area for each physical device. Is or a pointer to an extension-specific structure.

Use Windows keyex mutex mechanism to synchronize work. When submitting work that operates on memory imported from a Direct3D 11 resource to a queue, the keyed mutex mechanism may be used in addition to Vulkan semaphores to synchronize the work.

The type of this structure.

Pointer to next structure.

the number of entries in the , , and arrays.

An array of objects which were imported from Direct3D 11 resources.

Mutex key values to wait for prior to beginning the submitted work. Entries refer to the keyed mutex associated with the corresponding entries in .

Timeout values, in millisecond units, for each acquire specified in .

The number of entries in the and arrays.

An array of objects which were imported from Direct3D 11 resources.

Mutex key values to set when the submitted work has completed. Entries refer to the keyed mutex associated with the corresponding entries in .

Initializes a new instance of the structure.

An array of objects which were imported from Direct3D 11 resources. Mutex key values to wait for prior to beginning the submitted work. Timeout values, in millisecond units, for each acquire specified in . An array of objects which were imported from Direct3D 11 resources. An array of objects which were imported from Direct3D 11 resources.

Structure indicating which physical devices execute semaphore operations and command buffers.

The type of this structure.

Is or a pointer to an extension-specific structure.

The number of elements in the array.

Device indices indicating which physical device executes the semaphore wait operation in the corresponding element of .

The number of elements in the array.

Device masks indicating which physical devices execute the command buffer in the corresponding element of . A physical device executes the command buffer if the corresponding bit is set in the mask.

The number of elements in the array.

Device indices indicating which physical device executes the semaphore signal operation in the corresponding element of .

Initializes a new instance of the structure.

Device indices indicating which physical device executes the semaphore wait operation in the corresponding element of . Device masks indicating which physical devices execute the command buffer in the corresponding element of . A physical device executes the command buffer if the corresponding bit is set in the mask. Device indices indicating which physical device executes the semaphore signal operation in the corresponding element of . Is or a pointer to an extension-specific structure.

Provides experimental Khronos specific extension methods for the class.

Query supported peer memory features of a device. Peer memory is memory that is allocated for a given physical device and then bound to a resource and accessed by a different physical device, in a logical device that represents multiple physical devices.

The logical device that owns the memory. The index of the memory heap from which the memory is allocated. The device index of the physical device that performs the memory access. The device index of the physical device that the memory is allocated for. A bitmask indicating which types of memory accesses are supported for the combination of heap, local, and remote devices.

Bind device memory to buffer objects.

The logical device that owns the buffers and memory. Structures describing buffers and memory to bind. Vulkan returns an error code.

Bind device memory to image objects.

The logical device that owns the images and memory. Structures describing images and memory to bind. Vulkan returns an error code.

Query present capabilities from other physical devices. A logical device that represents multiple physical devices may support presenting from images on more than one physical device, or combining images from multiple physical devices.

The logical device. Structure that is filled with the logical device's capabilities. Vulkan returns an error code.

Query present capabilities for a surface. Some surfaces may not be capable of using all the device group present modes.

The logical device. The surface. A value that is filled with the supported device group present modes for the surface. Vulkan returns an error code.

Retrieve the index of the next available presentable image.

The device associated with . Structure containing parameters of the acquire. The index of the next image to use. Vulkan returns an error code.

Bitmask specifying supported peer memory features.

Indicates that the memory can be accessed as the source of a CommandBuffer.CmdCopy* command.

Indicates that the memory can be accessed as the destination of a CommandBuffer.CmdCopy* command.

Indicates that the memory can be read as any other memory access type.

Indicates that the memory can be written as any other memory access type. Shader atomics are considered to be writes.

Structure specifying how to bind a buffer to memory.

Is or a pointer to an extension-specific structure.

The to be attached to memory.

A object describing the device memory to attach.

The start offset of the region of memory which is to be bound to the buffer. The number of bytes returned in the member in memory, starting from bytes, will be bound to the specified buffer.

An array of device indices.

Initializes a new instance of the structure.

The to be attached to memory. A object describing the device memory to attach. The start offset of the region of memory which is to be bound to the buffer. The number of bytes returned in the member in memory, starting from bytes, will be bound to the specified buffer. An array of device indices. Is or a pointer to an extension-specific structure.

Structure specifying how to bind an image to memory.

Is or a pointer to an extension-specific structure.

The to be attached to memory.

A object describing the device memory to attach.

The start offset of the region of memory which is to be bound to the image. If the length of is zero, the number of bytes returned in the member in memory, starting from bytes, will be bound to the specified image.

An array of device indices.

An array of rectangles describing which regions of the image are attached to each instance of memory.

Initializes a new instance of the structure.

The to be attached to memory. A object describing the device memory to attach. The start offset of the region of memory which is to be bound to the image. If the length of is zero, the number of bytes returned in the member in memory, starting from bytes, will be bound to the specified image. An array of device indices. An array of rectangles describing which regions of the image are attached to each instance of memory. Is or a pointer to an extension-specific structure.

Present capabilities from other physical devices.

Is or a pointer to an extension-specific structure.

An array of masks, where the mask at element [i] is non-zero if physical device [i] has a presentation engine, and where bit [j] is set in element [i] if physical device [i] can present swapchain images from physical device [j]. If element [i] is non-zero, then bit [i] must be set.

A bitmask indicating which device group presentation modes are supported.

Bitmask specifying supported device group present modes.

Indicates that any physical device with a presentation engine can present its own swapchain images.

Indicates that any physical device with a presentation engine can present swapchain images from any physical device in its present mask.

Indicates that any physical device with a presentation engine can present the sum of swapchain images from any physical devices in its present mask.

Indicates that multiple physical devices with a presentation engine can each present their own swapchain images.

Structure specifying parameters of the acquire.

Is or a pointer to an extension-specific structure.

The from which an image is being acquired.

Indicates how long the function waits, in nanoseconds, if no image is available.

Is 0 or a to signal.

A mask of physical devices for which the swapchain image will be ready to use when the semaphore or fence is signaled.

Initializes a new instance of the structure.

The from which an image is being acquired. Indicates how long the function waits, in nanoseconds, if no image is available. A to signal. A to signal. A mask of physical devices for which the swapchain image will be ready to use when the semaphore or fence is signaled. Is or a pointer to an extension-specific structure.

Structure describing multiview features that can be supported by an implementation.

The type of this structure.

Pointer to next structure.

Multiple views in a renderpass.

Multiple views in a renderpass w/ geometry shader.

Multiple views in a renderpass w/ tessellation shader.

Initializes a new instance of the structure.

Multiple views in a renderpass. Multiple views in a renderpass w/ geometry shader. Multiple views in a renderpass w/ tessellation shader. Pointer to next structure.

Create a logical device from multiple physical devices.

The type of this structure.

Is or a pointer to an extension-specific structure.

The number of elements in the array.

A pointer to an array of handles belonging to the same device group.

Initializes a new instance of the structure.

The number of elements in the array. A pointer to an array of handles belonging to the same device group. Is or a pointer to an extension-specific structure.

Structure specifying swapchain image memory to bind to.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is 0 or a handle.

An image index within .

Initializes a new instance of the structure.

Is null or a handle. An image index within . Is or a pointer to an extension-specific structure.

Structure specifying parameters of a newly created swapchain object.

The type of this structure.

Is or a pointer to an extension-specific structure.

A bitfield of modes that the swapchain can be used with.

Initializes a new instance of the structure.

A bitfield of modes that the swapchain can be used with. Is or a pointer to an extension-specific structure.

Mode and mask controlling which physical devices' images are presented.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is zero or the number of elements in .

An array of device masks, one for each element of .

The device group present mode that will be used for this present.

Initializes a new instance of the structure.

Is zero or the number of elements in . An array of device masks, one for each element of . The device group present mode that will be used for this present. Is or a pointer to an extension-specific structure.

The type of this structure.

Is or a pointer to an extension-specific structure.

A bitmask of flags controlling the allocation.

A mask of physical devices in the logical device, indicating that memory must be allocated on each device in the mask, if is set.

Initializes a new instance of the structure.

A bitmask of flags controlling the allocation. A mask of physical devices in the logical device, indicating that memory must be allocated on each device in the mask, if is set. Is or a pointer to an extension-specific structure.

Bitmask specifying flags for a device memory allocation.

No flags.

Specifies that memory will be allocated for the devices in .

Specify that an image will be bound to swapchain memory.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is 0 or a handle of an that the image will be bound to.

Initializes a new instance of the structure.

Is null or a handle of an that the image will be bound to. Is or a pointer to an extension-specific structure.

Structure indicating which instances are bound.

The type of this structure.

Is or a pointer to an extension-specific structure.

A device index indicating which instance of the resource is bound.

A device index indicating which instance of the memory the resource instance is bound to.

Initializes a new instance of the structure.

A device index indicating which instance of the resource is bound. A device index indicating which instance of the memory the resource instance is bound to. Is or a pointer to an extension-specific structure.

Provides experimental Khronos specific extension methods for the class.

Enumerates groups of physical devices that can be used to create a single logical device.

A handle to a previously created Vulkan instance. An array of structures. Vulkan returns an error code.

Structure specifying physical device group properties.

Is or a pointer to an extension-specific structure.

An array of physical device handles representing all physical devices in the group.

Indicates whether logical devices created from the group support allocating device memory on a subset of devices, via the member. If this is false, then all device memory allocations are made across all physical devices in the group. If length is 1, then must be false.

Provides experimental Khronos specific extension methods for the class.

Query present rectangles for a surface on a physical device. When using , the application may need to know which regions of the surface are used when presenting locally on each physical device. Presentation of swapchain images to this surface need only have valid contents in the regions returned by this command.

The physical device. The surface. An array of structures. Vulkan returns an error code.

Structure describing multiview limits that can be supported by an implementation.

Pointer to next structure.

Max number of views in a subpass.

Max instance index for a draw in a multiview subpass.

Provides Brenwill Workshop specific extension methods for the class.

Create a object for an iOS UIView.

The instance with which to associate the surface. Structure containing parameters affecting the creation of the surface object. The allocator used for host memory allocated for the surface object when there is no more specific allocator available The created surface object. Vulkan returns an error code.

Create a object for a macOS NSView.

The instance with which to associate the surface. Structure containing parameters affecting the creation of the surface object. The allocator used for host memory allocated for the surface object when there is no more specific allocator available. The created surface object. Vulkan returns an error code.

Structure specifying parameters of a newly created iOS surface object.

Is or a pointer to an extension-specific structure.

Must be a valid UIView and must be backed by a CALayer instance of type CAMetalLayer.

Is reserved for future use.

Structure specifying parameters of a newly created macOS surface object.

Is or a pointer to an extension-specific structure.

Must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer.

Is reserved for future use.

Provides Nintendo specific extension methods for the class.

Create a object for a VI layer. During the lifetime of a surface created using a particular `NativeWindowHandle`, any attempts to create another surface for the same `Layer` and any attempts to connect to the same layer through other platform mechanisms will have undefined results. The of a VI surface is always undefined. Applications are expected to choose an appropriate size for the swapchain's (e.g., by matching the the result of a call to `GetDisplayResolution`).

Structure specifying parameters of a newly created VI surface object.

The `NativeWindowHandle` for the `Layer` with which to associate the surface.

Provides NVIDIA specific extension methods for the class.

Performs the generation of commands on the device.

The primary command buffer in which the generation process takes space. The structure containing parameters affecting the processing of commands.

Perform a reservation of command buffer space. The must not have had a prior space reservation since its creation or the last reset. The state of the must be legal to execute all commands within the sequence provided by the member.

The secondary command buffer in which the space for device-generated commands is reserved. The structure containing parameters affecting the reservation of command buffer space.

Structure specifying parameters for the generation of commands.

The to be used for the generation process. Only registered objects at the time is called, will be taken into account for the reservation.

The that provides the command sequence to generate.

Provides an array of that reference the input data for each token command.

The maximum number of sequences for which command buffer space will be reserved. If is 0, this is also the actual number of sequences generated.

Can be the secondary in which the commands should be recorded. If is an implicit reservation as well as execution takes place on the processing .

Can be from which the actual amount of sequences is sourced from as value.

The byte offset into where the count value is stored.

Must be set if 's bit is set and provides the used sequence indices as array. Otherwise it must be 0.

The byte offset into where the index values start.

Initializes a new instance of the structure.

The to be used for the generation process. Only registered objects at the time is called, will be taken into account for the reservation. The that provides the command sequence to generate. Provides an array of that reference the input data for each token command. The maximum number of sequences for which command buffer space will be reserved. If is 0, this is also the actual number of sequences generated. Can be the secondary in which the commands should be recorded. If null an implicit reservation as well as execution takes place on the processing . Can be from which the actual amount of sequences is sourced from as value. The byte offset into where the count value is stored. Must be set if 's bit is set and provides the used sequence indices as array. Otherwise it must be 0. The byte offset into where the index values start.

Structure specifying parameters for the reservation of command buffer space.

Specifies the token command type.

Specifies the storing the functional arguments for each squence. These argumetns can be written by the device.

Specified an offset into where the arguments start.

Initializes a new instance of the structure.

Specifies the token command type. Specifies the storing the functional arguments for each squence. These argumetns can be written by the device. Specified an offset into where the arguments start.

Structure specifying parameters for the reservation of command buffer space.

The to be used for the generation process. Only registered objects at the time is called, will be taken into account for the reservation.

The that must also be used at generation time.

The maximum number of sequences for which command buffer space will be reserved.

Initializes a new instance of the structure.

The to be used for the generation process. Only registered objects at the time is called, will be taken into account for the reservation. The that must also be used at generation time. The maximum number of sequences for which command buffer space will be reserved.

Provides NVIDIA specific extension methods for the class.

Vulkan returns an error code. Vulkan returns an error code.

Opaque handle to an indirect commands layout object. The device-side command generation happens through an iterative processing of an atomic sequence comprised of command tokens, which are represented by .

Gets the parent of this resource.

Destroy an indirect commands layout object.

Structure specifying the parameters of a newly created indirect commands layout object.

The that this layout targets.

A bitmask providing usage hints of this layout.

An array describing each command token in detail. See and for details.

Initializes a new instance of the structure.

The that this layout targets. A bitmask providing usage hints of this layout. An array describing each command token in detail. See and for details.

Structure specifying the details of an indirect command layout token.

Specifies the token command type.

Has a different meaning depending on the type.

Defines the rate at which the input data buffers are accessed.

Enum specifying the token command type.

Equivalent command: .

Bitmask specifying allowed usage of a indirect commands layout.

Indicates that the processing of sequences can happen at an implementation-dependent order, which is not guaranteed to be coherent across multiple invocations.

Indicates that there is likely a high difference between allocated number of sequences and actually used.

Indicates that there are likely many draw or dispatch calls that are zero-sized (zero grid dimension, no primitives to render).

Indicates that the input data for the sequences is not implicitly indexed from 0..sequences used but a user provided encoding the index is provided.

Opaque handle to an object table. The device-side bindings are registered inside a table.

Gets the parent of this resource.

Vulkan returns an error code. Vulkan returns an error code.

Destroy an object table.

Structure specifying the parameters of a newly created object table.

An array providing the entry type of a given configuration.

An array of how many objects can be registered in the table.

An array of bitmasks describing the binding usage of the entry.

The maximum number of or used by any single registered in this table.

The maximum number of , , or used by any single registered in this table.

The maximum number of unique used by any registered or in this table.

Bitmask specifying allowed usage of an object entry.

Indicates that the resource is bound to .

Common parameters of an object table resource entry.

Defines the entry type.

Defines which the resource can be used with. Some entry types allow only a single flag to be set.

Enum specifying object table entry type.

Indicates a resource entry that is registered via .

Indicates the resource entry is registered via .

Parameters of an object table pipeline entry.

Defines the entry type.

Defines which the resource can be used with. Some entry types allow only a single flag to be set.

Specifies the that this resource entry references.

Parameters of an object table descriptor set entry.

Defines the entry type.

Defines which the resource can be used with. Some entry types allow only a single flag to be set.

Specifies the that the is used with.

Specifies the that can be bound with this entry.

Parameters of an object table vertex buffer entry.

Defines the entry type.

Defines which the resource can be used with. Some entry types allow only a single flag to be set.

Specifies the that can be bound as vertex buffer.

Parameters of an object table index buffer entry.

Defines the entry type.

Defines which the resource can be used with. Some entry types allow only a single flag to be set.

Specifies the that can be bound as index buffer.

Specifies the used with this index buffer.

Parameters of an object table push constant entry.

Defines the entry type.

Defines which the resource can be used with. Some entry types allow only a single flag to be set.

Specifies the that push constants using this object index are used with.

The that push constants using this object index are used with.

Provides NVIDIA specific extension methods for the class.

Returns device-generated commands related properties of a physical device.

The handle to the physical device whose properties will be queried. Structures that will be filled with returned information.

Structure specifying physical device support.

Indicates whether the supports entries with bit set and supports .

Structure specifying physical device limits.

The maximum number of tokens in .

The maximum number of entries per resource type in .

The minimum alignment for memory addresses optionally used in .

Structure describing multiview limits that can be supported by an implementation.

Pointer to next structure.

Is true if the implementation supports per-view position values that differ in components other than the X component.

Provides NVIDIA specific extension methods for the class.

Set the viewport W scaling on a command buffer.

The command buffer into which the command will be recorded. The index of the first viewport whose parameters are updated by the command. Structures specifying viewport parameters.

Structure specifying a viewport.

The viewport's W scaling factor for x.

The viewport's W scaling factor for y.

Initializes a new instance of the structure.

The viewport's W scaling factor for x. The viewport's W scaling factor for y.

Structure specifying parameters of a newly created pipeline viewport W scaling state.

The type of this structure.

Is or a pointer to an extension-specific structure.

The enable for viewport W scaling.

The number of viewports used by W scaling and must match the number of viewports in the pipeline if viewport W scaling is enabled.

Structures which define the W scaling parameters for the corresponding viewport. If the viewport W scaling state is dynamic, this member is ignored.

Initializes a new instance of the structure.

The enable for viewport W scaling. Structures which define the W scaling parameters for the corresponding viewport. If the viewport W scaling state is dynamic, this member is ignored. Is or a pointer to an extension-specific structure.

The type of this structure.

Is or a pointer to an extension-specific structure.

the number of entries in the , , and arrays.

An array of objects which were imported from Direct3D 11 resources.

Mutex key values to wait for prior to beginning the submitted work. Entries refer to the keyed mutex associated with the corresponding entries in .

Timeout values, in millisecond units, for each acquire specified in .

The number of entries in the and arrays.

An array of objects which were imported from Direct3D 11 resources.

Mutex key values to set when the submitted work has completed. Entries refer to the keyed mutex associated with the corresponding entries in .

Initializes a new instance of the structure.

Provides NVIDIA specific extension methods for the class.

Retrieve Win32 handle to a device memory object.

Opaque handle to a device memory object. A bitmask containing a single bit specifying the type of handle requested. A Windows HANDLE. Vulkan returns an error code.

Bitmask specifying external memory handle types.

No flags.

Indicates a handle to memory returned by or, one duplicated from such a handle using DuplicateHandle().

Indicates a handle to memory returned by .

Indicates a valid NT handle to memory returned by IDXGIResource1::ftext:CreateSharedHandle(), or a handle duplicated from such a handle using DuplicateHandle().

Indicates a handle to memory returned by IDXGIResource::GetSharedHandle().

Specify a dedicated memory allocation resource.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is 0 or a handle of an which this memory will be bound to.

Is 0 or a handle of a which this memory will be bound to.

Initializes a new instance of the structure.

Is null or an which this memory will be bound to. Is or a pointer to an extension-specific structure.

Initializes a new instance of the structure.

A buffer which this memory will be bound to. Is or a pointer to an extension-specific structure.

Specify that a buffer is bound to a dedicated memory resource.

The type of this structure.

Is or a pointer to an extension-specific structure.

Indicates whether the buffer will have a dedicated allocation bound to it.

Initializes a new instance of the structure.

Indicates whether the buffer will have a dedicated allocation bound to it. Is or a pointer to an extension-specific structure.

Specify that an image is bound to a dedicated memory resource.

The type of this structure.

Is or a pointer to an extension-specific structure.

Indicates whether the image will have a dedicated allocation bound to it.

Initializes a new instance of the structure.

Indicates whether the image will have a dedicated allocation bound to it. Is or a pointer to an extension-specific structure.

Import Win32 memory created on the same physical device.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is 0 or a value specifying the type of memory handle in handle.

A Windows HANDLE referring to the memory.

Initializes a new instance of the structure.

A Windows HANDLE referring to the memory. Is 0 or a value specifying the type of memory handle in handle. Is or a pointer to an extension-specific structure.

Specify memory handle types that may be exported.

The type of this structure.

Is or a pointer to an extension-specific structure.

Specifies one or more memory handle types that may be exported. Multiple handle types may be requested for the same allocation as long as they are compatible, as reported by .

Initializes a new instance of the structure.

Specifies one or more memory handle types that may be exported. Multiple handle types may be requested for the same allocation as long as they are compatible, as reported by . Is or a pointer to an extension-specific structure.

Provides NVIDIA specific extension methods for the class.

Determine image capabilities compatible with external memory handle types.

The physical device from which to query the image capabilities. The image format, corresponding to . The image type, corresponding to . The image tiling, corresponding to . The intended usage of the image, corresponding to . A bitmask describing additional parameters of the image, corresponding to . Either one of the bits from , or 0. The structure in which capabilities are returned. Vulkan returns an error code.

Structure specifying external image format properties.

Will be filled in as when calling , but the values returned may vary depending on the external handle type requested.

A bitmask of indicating properties of the external memory handle type being queried, or 0 if the external memory handle type is 0.

A bitmask of containing a bit set for every external handle type that may be used to create memory from which the handles of the type can be exported, or 0 if the external memory handle type is 0.

A bitmask of containing a bit set for every external handle type that may be specified simultaneously with the handle type when calling , or 0 if the external memory handle type is 0.

Bitmask specifying external memory features.

Indicates that external memory of the specified type must be created as a dedicated allocation when used in the manner specified.

Indicates that the implementation supports exporting handles of the specified type.

Indicates that the implementation supports importing handles of the specified type.

Structure specifying swizzle applied to primitive clip coordinates. Each primitive sent to a given viewport has a swizzle and optional negation applied to its clip coordinates.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is reserved for future use.

The number of viewport swizzles used by the pipeline.

A pointer to an array of structures, defining the viewport swizzles.

Initializes a new instance of the structure.

The number of viewport swizzles used by the pipeline. A pointer to an array of structures, defining the viewport swizzles. Is or a pointer to an extension-specific structure.

No flags.

Structure specifying a viewport swizzle.

Specifies the swizzle operation to apply to the x component of the primitive.

Specifies the swizzle operation to apply to the y component of the primitive.

Specifies the swizzle operation to apply to the z component of the primitive.

Specifies the swizzle operation to apply to the w component of the primitive.

Specify how a viewport coordinate is swizzled.

Specify the discard rectangle mode.

Specifies that no components are multiplied by the modulation factor.

Specifies that the red, green, and blue components are multiplied by the modulation factor.

Specifies that the alpha component is multiplied by the modulation factor.

Specifies that all components are multiplied by the modulation factor.

Structure specifying whether fragment coverage replaces a color.

The type of this structure.

Is or a pointer to an extension-specific structure.

Is reserved for future use.

Controls whether the fragment coverage value replaces a fragment color output.

Controls which fragment shader color output value is replaced.

No flags.

Specify an enumeration to track object handle types. The enumeration defines values, each of which corresponds to a specific Vulkan handle type. These values can be used to associate debug information with a particular type of object through one or more extensions.

Structure specifying a two-dimensional offset.

An with all of its components set to zero.

The X component of the offset.

The Y component of the offset.

Initializes a new instance of the structure.

The X component of the offset The Y component of the offset.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns the hash code for this instance.

The hash code.

Returns a boolean indicating whether the two given offsets are equal.

The first offset to compare. The second offset to compare. true if the offsets are equal; false otherwise.

Returns a boolean indicating whether the two given offsets are not equal.

The first offset to compare. The second offset to compare. true if the offsets are not equal; false if they are equal.

Structure specifying a three-dimensional offset.

An with all of its components set to zero.

The X component of the offset.

The Y component of the offset.

The Z component of the offset.

Initializes a new instance of the structure.

The X component of the offset The Y component of the offset. The Z component of the offset.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns the hash code for this instance.

The hash code.

Returns a boolean indicating whether the two given offsets are equal.

The first offset to compare. The second offset to compare. true if the offsets are equal; false otherwise.

Returns a boolean indicating whether the two given offsets are not equal.

The first offset to compare. The second offset to compare. true if the offsets are not equal; false if they are equal.

Opaque handle to a physical device object. Vulkan separates the concept of physical and logical devices. A physical device usually represents a single device in a system (perhaps made up of several individual hardware devices working together), of which there are a finite number. A logical device represents an application's view of the device.

Gets the parent of the resource.

Returns properties of a physical device.

Properties of a physical device.

Reports properties of the queues of the physical device.

Properties of the queues of the physical device.

Reports memory information for physical device.

Structure in which the properties are returned.

Reports capabilities of a physical device.

Capabilities of a physical device.

Lists physical device's format capabilities.

The format whose properties are queried. Format capabilities of a physical device.

Lists physical device's image format capabilities.

The image format, corresponding to . The image type, corresponding to . The image tiling, corresponding to . The intended usage of the image, corresponding to . A bitmask describing additional parameters of the image, corresponding to . Image format capabilities of a physical device Vulkan returns an error code.

Returns properties of available physical device extensions.

Returns properties of available physical device layers.

Properties of available layers.

Create a new device instance. A logical device is created as a connection to a physical device.

The structure containing information about how to create the device. Controls host memory allocation. Device instance. Vulkan returns an error code.

Retrieve properties of an image format applied to sparse images.

The image format. The dimensionality of image. The number of samples per pixel. The intended usage of the image. The tiling arrangement of the data elements in memory. Properties of an image format applied to sparse images.

Structure describing the fine-grained features that can be supported by an implementation.

Indicates that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by , , or the size of the buffer).

Full 32-bit range of indices for indexed draw calls.

Image views which are arrays of cube maps.

Blending operations are controlled per-attachment.

Geometry stage.

Tessellation control and evaluation stage.

Per-sample shading and interpolation.

Blend operations which take two sources.

Logic operations.

Multi draw indirect.

Indirect draws can use non-zero firstInstance.

Depth clamping.

Depth bias clamping.

Point and wireframe fill modes.

Depth bounds test.

Lines with width greater than 1.

Points with size greater than 1.

The fragment alpha component can be forced to maximum representable alpha value.

Viewport arrays.

Anisotropic sampler filtering.

ETC texture compression formats.

ASTC LDR texture compression formats.

BC1-7 texture compressed formats.

Precise occlusion queries returning actual sample counts.

Pipeline statistics query.

Stores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages.

Stores and atomic ops on storage buffers and images are supported in the fragment stage.

Tessellation and geometry stages can export point size.

Image gather with run-time values and independent offsets.

The extended set of formats can be used for storage images.

Multisample images can be used for storage images.

Read from storage image does not require format qualifier.

Write to storage image does not require format qualifier.

Arrays of uniform buffers can be accessed with dynamically uniform indices.

Arrays of sampled images can be accessed with dynamically uniform indices.

Arrays of storage buffers can be accessed with dynamically uniform indices.

Arrays of storage images can be accessed with dynamically uniform indices.

Clip distance in shaders.

Cull distance in shaders.

64-bit floats (doubles) in shaders.

64-bit integers in shaders.

16-bit integers in shaders.

Shader can use texture operations that return resource residency information (requires sparseNonResident support).

Shader can use texture operations that specify minimum resource level of detail.

Sparse resources support: resource memory can be managed at opaque page level rather than object level.

Sparse resources support: GPU can access partially resident buffers.

Sparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images.

Sparse resources support: GPU can access partially resident 3D images.

Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples.

Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples.

Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples.

Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples.

Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in).

Multisample rate must be the same for all pipelines in a subpass.

Queries may be inherited from primary to secondary command buffers.

Structure reporting implementation-dependent physical device limits.

The maximum dimension (width) of an image created with an .

The maximum dimension (width or height) of an image created with an and without set in flags.

The maximum dimension (width, height, or depth) of an image created with an .

The maximum dimension (width or height) of an image created with an and with set in flags.

The maximum number of layers (array layers) for an image.

The maximum number of addressable texels for a buffer view created on a buffer which was created with the or set in the member.

The maximum value that can be specified in the range member of any structures passed to a call to for descriptors of type or .

The maximum size, in bytes, of the pool of push constant memory. For each of the push constant ranges indicated by the member, + must be less than or equal to this limit.

The maximum number of device memory allocations, as created by , which can simultaneously exist.

The maximum number of sampler objects, as created by , which can simultaneously exist on a device.

The granularity, in bytes, at which buffer or linear image resources, and optimal image resources can be bound to adjacent offsets in the same object without aliasing.

The total amount of address space available, in bytes, for sparse memory resources. This is an upper bound on the sum of the size of all sparse resources, regardless of whether any memory is bound to them.

The maximum number of descriptor sets that can be simultaneously used by a pipeline. All decorations in shader modules must have a value less than .

The maximum number of samplers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of or count against this limit. A descriptor is accessible to a shader stage when the member has the bit for that shader stage set.

The maximum number of uniform buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of or count against this limit. A descriptor is accessible to a shader stage when the member has the bit for that shader stage set.

The maximum number of storage buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of or count against this limit. A descriptor is accessible to a pipeline shader stage when the member has the bit for that shader stage set.

The maximum number of sampled images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of , , or count against this limit. A descriptor is accessible to a pipeline shader stage when the member has the bit for that shader stage set.

The maximum number of storage images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of , or count against this limit. A descriptor is accessible to a pipeline shader stage when the member has the bit for that shader stage set.

The maximum number of input attachments that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of count against this limit. A descriptor is accessible to a pipeline shader stage when the member has the bit for that shader stage set. These are only supported for the fragment stage.

The maximum number of resources that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of , , , , , , , , , or count against this limit. For the fragment shader stage the framebuffer color attachments also count against this limit.

The maximum number of samplers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of or count against this limit.

The maximum number of uniform buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of or count against this limit.

The maximum number of dynamic uniform buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of count against this limit.

The maximum number of storage buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of or count against this limit.

The maximum number of dynamic storage buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of count against this limit.

The maximum number of sampled images that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of , , or count against this limit.

The maximum number of storage images that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of , or count against this limit.

The maximum number of input attachments that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of count against this limit.

The maximum number of vertex input attributes that can be specified for a graphics pipeline. These are described in the array of structures that are provided at graphics pipeline creation time via the member.

The maximum number of vertex buffers that can be specified for providing vertex attributes to a graphics pipeline. These are described in the array of structures that are provided at graphics pipeline creation time via the member. The member must be less than this limit.

The maximum vertex input attribute offset that can be added to the vertex input binding stride. The member structure must be less than or equal to this limit.

The maximum vertex input binding stride that can be specified in a vertex input binding. The member must be less than or equal to this limit.

The maximum number of components of output variables which can be output by a vertex shader.

The maximum tessellation generation level supported by the fixed-function tessellation primitive generator.

The maximum patch size, in vertices, of patches that can be processed by the tessellation control shader and tessellation primitive generator. The member specified at pipeline creation time and the value provided in the OutputVertices execution mode of shader modules must be less than or equal to this limit.

The maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation control shader stage.

The maximum number of components of per-vertex output variables which can be output from the tessellation control shader stage.

The maximum number of components of per-patch output variables which can be output from the tessellation control shader stage.

The maximum total number of components of per-vertex and per-patch output variables which can be output from the tessellation control shader stage.

The maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation evaluation shader stage.

The maximum number of components of per-vertex output variables which can be output from the tessellation evaluation shader stage.

The maximum invocation count supported for instanced geometry shaders. The value provided in the`Invocations execution mode of shader modules must be less than or equal to this limit.

The maximum number of components of input variables which can be provided as inputs to the geometry shader stage.

The maximum number of components of output variables which can be output from the geometry shader stage.

The maximum number of vertices which can be emitted by any geometry shader.

The maximum total number of components of output, across all emitted vertices, which can be output from the geometry shader stage.

The maximum number of components of input variables which can be provided as inputs to the fragment shader stage.

The maximum number of output attachments which can be written to by the fragment shader stage.

The maximum number of output attachments which can be written to by the fragment shader stage when blending is enabled and one of the dual source blend modes is in use.

The total number of storage buffers, storage images, and output buffers which can be used in the fragment shader stage.

The maximum total storage size, in bytes, of all variables declared with the WorkgroupLocal storage class in shader modules (or with the shared storage qualifier in GLSL) in the compute shader stage.

The maximum number of local workgroups that can be dispatched by a single dispatch command. This value represents the maximum number of local workgroups for the X dimension. The x parameter to the command must be less than or equal to the limit.

The maximum number of local workgroups that can be dispatched by a single dispatch command. This value represents the maximum number of local workgroups for the Y dimension. The y parameter to the command must be less than or equal to the limit.

The maximum number of local workgroups that can be dispatched by a single dispatch command. This value represents the maximum number of local workgroups for the Z dimension. The z parameter to the command must be less than or equal to the limit.

The maximum total number of compute shader invocations in a single local workgroup. The product of the X, Y, and Z sizes as specified by the LocalSize execution mode in shader modules and by the object decorated by the WorkgroupSize decoration must be less than or equal to this limit.

The maximum size of a local compute workgroup, per dimension. This value represents the maximum local workgroup size in the X dimension. The x size specified by the LocalSize execution mode and by the object decorated by the WorkgroupSize decoration in shader modules must be less than or equal to the limit.

The maximum size of a local compute workgroup, per dimension. This value represents the maximum local workgroup size in the Y dimension. The y size specified by the LocalSize execution mode and by the object decorated by the WorkgroupSize decoration in shader modules must be less than or equal to the limit.

The maximum size of a local compute workgroup, per dimension. This value represents the maximum local workgroup size in the Z dimension. The z size specified by the LocalSize execution mode and by the object decorated by the WorkgroupSize decoration in shader modules must be less than or equal to the limit.

The number of bits of subpixel precision in framebuffer coordinates.

The number of bits of precision in the division along an axis of an image used for minification and magnification filters. 2** is the actual number of divisions along each axis of the image represented. The filtering hardware will snap to these locations when computing the filtered results.

The number of bits of division that the LOD calculation for mipmap fetching get snapped to when determining the contribution from each mip level to the mip filtered results. 2** is the actual number of divisions. For example, if this value is 2 bits then when linearly filtering between two levels, each level could contribute: 0%, 33%, 66%, or 100% (this is just an example and the amount of contribution should be covered by different equations in the spec).

The maximum index value that can be used for indexed draw calls when using 32-bit indices. This excludes the primitive restart index value of 0xFFFFFFFF.

The maximum draw count that is supported for indirect draw calls.

The maximum absolute sampler level of detail bias. The sum of the member and the Bias operand of image sampling operations in shader modules (or 0 if no Bias operand is provided to an image sampling operation) are clamped to the range [-,+].

The maximum degree of sampler anisotropy. The maximum degree of anisotropic filtering used for an image sampling operation is the minimum of the member and this limit.

The maximum number of active viewports. The member length that is provided at pipeline creation must be less than or equal to this limit.

The maximum viewport width in the X dimension. The maximum viewport dimension must be greater than or equal to the largest image which can be created and used as a framebuffer attachment.

The maximum viewport height in Y dimension. The maximum viewport dimension must be greater than or equal to the largest image which can be created and used as a framebuffer attachment.

The minimum of the range that the corners of a viewport must be contained in. This range must be at least [-2 × size, 2 × size - 1], where size = max( , ). The intent of the limit is to allow a maximum sized viewport to be arbitrarily shifted relative to the output target as long as at least some portion intersects. This would give a bounds limit of [-size + 1, 2 × size - 1] which would allow all possible non-empty-set intersections of the output target and the viewport. Since these numbers are typically powers of two, picking the signed number range using the smallest possible number of bits ends up with the specified range.

The maximum of the range that the corners of a viewport must be contained in. This range must be at least [-2 × size, 2 × size - 1], where size = max( , ). The intent of the limit is to allow a maximum sized viewport to be arbitrarily shifted relative to the output target as long as at least some portion intersects. This would give a bounds limit of [-size + 1, 2 × size - 1] which would allow all possible non-empty-set intersections of the output target and the viewport. Since these numbers are typically powers of two, picking the signed number range using the smallest possible number of bits ends up with the specified range.

The number of bits of subpixel precision for viewport bounds. The subpixel precision that floating-point viewport bounds are interpreted at is given by this limit.

The minimum required alignment, in bytes, of host visible memory allocations within the host address space. When mapping a memory allocation with , subtracting offset bytes from the returned pointer will always produce an integer multiple of this limit.

The minimum required alignment, in bytes, for the member for texel buffers. When a buffer view is created for a buffer which was created with or set in the member, the offset must be an integer multiple of this limit.

The minimum required alignment, in bytes, for the offset member of the structure for uniform buffers. When a descriptor of type or is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for uniform buffers must be multiples of this limit.

The minimum required alignment, in bytes, for the offset member of the structure for storage buffers. When a descriptor of type or is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for storage buffers must be multiples of this limit.

The minimum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.

The maximum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.

The minimum offset value for the Offset or ConstOffsets image operands of any of the OpImage*Gather image instructions.

The maximum offset value for the Offset or ConstOffsets image operands of any of the OpImage*Gather image instructions.

The minimum negative offset value for the offset operand of the InterpolateAtOffset extended instruction.

The maximum positive offset value for the offset operand of the InterpolateAtOffset extended instruction.

The number of subpixel fractional bits that the x and y offsets to the InterpolateAtOffset extended instruction may be rounded to as fixed-point values.

The maximum width for a framebuffer. The member must be less than or equal to this limit.

The maximum height for a framebuffer. The member must be less than or equal to this limit.

The maximum layer count for a layered framebuffer. The member must be less than or equal to this limit.

A bitmask indicating the color sample counts that are supported for all framebuffer color attachments.

A bitmask indicating the supported depth sample counts for all framebuffer depth/stencil attachments, when the format includes a depth component.

A bitmask of bits indicating the supported stencil sample counts for all framebuffer depth/stencil attachments, when the format includes a stencil component.

A bitmask of bits indicating the supported sample counts for a framebuffer with no attachments.

The maximum number of color attachments that can be used by a subpass in a render pass. The length must be less than or equal to this limit.

A bitmask indicating the sample counts supported for all 2D images created with , usage containing , and a non-integer color format.

A bitmask indicating the sample counts supported for all 2D images created with , usage containing , and an integer color format.

A bitmask indicating the sample counts supported for all 2D images created with , usage containing , and a depth format.

A bitmask indicating the sample supported for all 2D images created with , usage containing , and a stencil format.

A bitmask indicating the sample counts supported for all 2D images created with , and usage containing .

The maximum number of array elements of a variable decorated with the SampleMask built-in decoration.

Indicates support for timestamps on all graphics and compute queues. If this limit is set to true, all queues that advertise the or in the support of at least 36.

The number of nanoseconds required for a timestamp query to be incremented by 1.

The maximum number of clip distances that can be used in a single shader stage. The size of any array declared with the ClipDistance built-in decoration in a shader module must be less than or equal to this limit.

The maximum number of cull distances that can be used in a single shader stage. The size of any array declared with the CullDistance built-in decoration in a shader module must be less than or equal to this limit.

The maximum combined number of clip and cull distances that can be used in a single shader stage. The sum of the sizes of any pair of arrays declared with the ClipDistance and CullDistance built-in decoration used by a single shader stage in a shader module must be less than or equal to this limit.

The number of discrete priorities that can be assigned to a queue based on the value of each member of VkDeviceQueueCreateInfo::pQueuePriorities. This must be at least 2, and levels must be spread evenly over the range, with at least one level at 1.0, and another at 0.0.

The minimum of the range of supported sizes for points. Values written to variables decorated with the PointSize built-in decoration are clamped to this range.

The maximum of the range of supported sizes for points. Values written to variables decorated with the PointSize built-in decoration are clamped to this range.

The minimum of the range of supported widths for lines. Values specified by the member or the line width parameter to are clamped to this range.

The maximum of the range of supported widths for lines. Values specified by the member or the line width parameter to are clamped to this range.

The granularity of supported point sizes. Not all point sizes in the range defined by and are supported. This limit specifies the granularity (or increment) between successive supported point sizes.

The granularity of supported line widths. Not all line widths in the range defined by and are supported. This limit specifies the granularity (or increment) between successive supported line widths.

Indicates whether lines are rasterized according to the preferred method of rasterization. If set to false, lines may be rasterized under a relaxed set of rules. If set to true, lines are rasterized as per the strict definition.

Indicates whether rasterization uses the standard sample locations. If set to true, the implementation uses the documented sample locations. If set to false, the implementation may use different sample locations.

The optimal buffer offset alignment in bytes for and . The per texel alignment requirements are still enforced, this is just an additional alignment recommendation for optimal performance and power.

The optimal buffer row pitch alignment in bytes for and . Row pitch is the number of bytes between texels with the same X coordinate in adjacent rows (Y coordinates differ by one). The per texel alignment requirements are still enforced, this is just an additional alignment recommendation for optimal performance and power.

The size and alignment in bytes that bounds concurrent access to host-mapped device memory.

Structure specifying physical device memory properties.

Structures describing the memory types that can be used to access memory allocated from the heaps specified by .

Structures describing the memory heaps from which memory can be allocated.

Structure specifying memory type.

A bitmask of properties for this memory type.

Describes which memory heap this memory type corresponds to, and must be less than the length of .

Structure specifying a memory heap.

The total memory size in bytes in the heap.

A bitmask of attribute flags for the heap.

Bitmask specifying properties for a memory type.

No flags.

Indicates that memory allocated with this type is the most efficient for device access. This property will only be set for memory types belonging to heaps with the set.

Indicates that memory allocated with this type can be mapped for host access using .

Indicates that the host cache management commands and are not needed to flush host writes to the device or make device writes visible to the host, respectively.

Indicates that memory allocated with this type is cached on the host. Host memory accesses to uncached memory are slower than to cached memory, however uncached memory is always host coherent.

Indicates that the memory type only allows device access to the memory. Memory types must not have both and set. Additionally, the object's backing memory may be provided by the implementation lazily.

Bitmask specifying attribute flags for a heap.

No flags.

Indicates that the heap corresponds to device local memory. Device local memory may have different performance characteristics than host local memory, and may support different memory property flags.

Indicates that in a logical device representing more than one physical device, there is a per-physical device instance of the heap memory. By default, an allocation from such a heap will be replicated to each physical device's instance of the heap.

Structure specifying physical device properties.

The version of Vulkan supported by the device.

The vendor-specified version of the driver.

A unique identifier for the vendor of the physical device.

A unique identifier for the physical device among devices available from the vendor.

Specifies the type of device.

The name of the device.

A universally unique identifier for the device.

Specifies device-specific limits of the physical device.

Specifies various sparse related properties of the physical device.

Structure specifying physical device sparse memory properties.

Is true if the physical device will access all single-sample 2D sparse resources using the standard sparse image block shapes (based on image format). If this property is not supported the value returned in the member for single-sample 2D images is not required to match the standard sparse image block dimensions listed in the table.

Is true if the physical device will access all multisample 2D sparse resources using the standard sparse image block shapes (based on image format). If this property is not supported, the value returned in the member for multisample 2D images is not required to match the standard sparse image block dimensions listed in the table.

Is true if the physical device will access all 3D sparse resources using the standard sparse image block shapes (based on image format). If this property is not supported, the value returned in the member for 3D images is not required to match the standard sparse image block dimensions listed in the table.

Is true if images with mip level dimensions that are not integer multiples of the corresponding dimensions of the sparse image block may: be placed in the mip tail. If this property is not reported, only mip levels with dimensions smaller than the imageGranularity member of the structure will be placed in the mip tail. If this property is reported the implementation is allowed to return in the flags member of , indicating that mip level dimensions that are not integer multiples of the corresponding dimensions of the sparse image block will be placed in the mip tail.

Specifies whether the physical device can consistently access non-resident regions of a resource. If this property is true, access to non-resident regions of resources will be guaranteed to return values as if the resource were populated with 0; writes to non-resident regions will be discarded.

Structure providing information about a queue family.

A bitmask indicating capabilities of the queues in this queue family.

The unsigned integer count of queues in this queue family.

The unsigned integer count of meaningful bits in the timestamps written via . The valid range for the count is 36..64 bits, or a value of 0, indicating no support for timestamps. Bits outside the valid range are guaranteed to be zeros.

The minimum granularity supported for image transfer operations on the queues in this queue family.

Bitmask specifying capabilities of queues in a queue family.

Indicates that queues in this queue family support graphics operations.

Indicates that queues in this queue family support compute operations.

Indicates that queues in this queue family support transfer operations.

Indicates that queues in this queue family support sparse resource memory management operations.

Structure specifying image format properties.

A bitmask specifying features supported by images created with a tiling parameter of .

A bitmask specifying features supported by buffers.

Bitmask specifying features supported by a buffer.

Specifies that an image view can be sampled from.

Specifies that an image view can be used as a storage image.

Specifies that an image view can be used as storage image that supports atomic operations.

Specifies that the format can be used to create a buffer view that can be bound to a descriptor.

Specifies that atomic operations are supported on with this format.

Specifies that the format can be used as a vertex attribute format ( ).

Specifies that an image view can be used as a framebuffer color attachment and as an input attachment.

Specifies that an image view can be used as a framebuffer color attachment that supports blending and as an input attachment.

Specifies that an image view can be used as a framebuffer depth/stencil attachment and as an input attachment.

Specifies that an image can be used as source image for the command.

Specifies that an image can be used as destination image for the command.

Specifies that if is also set, an image view can be used with a sampler that has either of magnification or minification filter set to , or mipmap mode set to . If is also set, an image can be used as the source image to with a . This bit must only be exposed for formats that also support the or .

An can be used with a sampler that has either of magnification or minification filter set to , or be the source image for a blit with filter set to . This bit must only be exposed for formats that also support the . If the format being queried is a depth/stencil format, this only indicates that the depth aspect is cubic filterable.

Specifies that an image can be used as a source image for copy commands.

Specifies that an image can be used as a destination image for copy commands and clear commands.

Specifies can be used as a sampled image with a min or max . This bit must only be exposed for formats that also support the .

Specifies the tiling arrangement of data in an image.

Specifies optimal tiling (texels are laid out in an implementation-dependent arrangement, for more optimal memory access).

Specifies linear tiling (texels are laid out in memory in row-major order, possibly with some padding on each row).

Specify filters used for texture lookups.

Specifies nearest filtering.

Specifies linear filtering.

Cubic filtering computes a set of neighboring coordinates which bound the unnormalized coordinates.

Supported physical device types.

The device does not match any other available types.

The device is typically one embedded in or tightly coupled with the host.

The device is typically a separate processor connected to the host via an interlink.

The device is typically a virtual node in a virtualization environment.

The device is typically running on the same processors as the host.

Opaque handle to a pipeline object.

Gets the parent of the resource.

Gets the cache of the resource.

Destroy a pipeline object.

Structure specifying parameters of a newly created graphics pipeline.

A bitmask specifying how the pipeline will be generated.

Structures describing the set of the shader stages to be included in the graphics pipeline.

An instance of the structure.

The structure which determines input assembly behavior.

An instance of the structure, and is ignored if the pipeline does not include a tessellation control shader stage and tessellation evaluation shader stage.

An instance of the structure, and is ignored if the pipeline has rasterization disabled.

An instance of the structure.

An instance of the , and is ignored if the pipeline has rasterization disabled.

An instance of the structure, and is ignored if the pipeline has rasterization disabled or if the subpass of the render pass the pipeline is created against does not use a depth/stencil attachment.

An instance of the structure, and is ignored if the pipeline has rasterization disabled or if the subpass of the render pass the pipeline is created against does not use any color attachments.

Is used to indicate which properties of the pipeline state object are dynamic and can be changed independently of the pipeline state. This can be null, which means no state in the pipeline is considered dynamic.

The description of binding locations used by both the pipeline and descriptor sets used with the pipeline.

A object describing the environment in which the pipeline will be used; the pipeline must only be used with an instance of any render pass compatible with the one provided.

The index of the subpass in the render pass where this pipeline will be used.

A pipeline to derive from.

An index into the create infos parameter to use as a pipeline to derive from.

Initializes a new instance of the structure.

The description of binding locations used by both the pipeline and descriptor sets used with the pipeline. A object describing the environment in which the pipeline will be used; the pipeline must only be used with an instance of any render pass compatible with the one provided. The index of the subpass in the render pass where this pipeline will be used. Structures describing the set of the shader stages to be included in the graphics pipeline. The structure which determines input assembly behavior. An instance of the structure. An instance of the structure. An instance of the structure, or null if the pipeline does not include a tessellation control shader stage and tessellation evaluation shader stage. An instance of the structure, or null if the pipeline has rasterization disabled. An instance of the , or null if the pipeline has rasterization disabled. An instance of the structure, or null if the pipeline has rasterization disabled or if the subpass of the render pass the pipeline is created against does not use a depth/stencil attachment. An instance of the structure, or null if the pipeline has rasterization disabled or if the subpass of the render pass the pipeline is created against does not use any color attachments. Is used to indicate which properties of the pipeline state object are dynamic and can be changed independently of the pipeline state. This can be null, which means no state in the pipeline is considered dynamic. A bitmask of controlling how the pipeline will be generated. A pipeline to derive from. An index into the create infos parameter to use as a pipeline to derive from.

Bitmask controlling how a pipeline is created.

No flags.

Specifies that the created pipeline will not be optimized. Using this flag may reduce the time taken to create the pipeline.

Specifies that the pipeline to be created is allowed to be the parent of a pipeline that will be created in a subsequent call to .

Specifies that the pipeline to be created will be a child of a previously created parent pipeline.

Specifies that any shader input variables decorated as device index will be assigned values as if they were decorated as view index.

Specifies that a compute pipeline can be used with with a non-zero base workgroup.

Structure specifying parameters of a newly created compute pipeline.

A bitmask specifying options for pipeline creation.

Describes the compute shader.

The description of binding locations used by both the pipeline and descriptor sets used with the pipeline. Must be consistent with the layout of the compute shader specified in stage.

A pipeline to derive from.

An index into the create infos parameter to use as a pipeline to derive from.

Initializes a new instance of the structure.

Describes the compute shader. The description of binding locations used by both the pipeline and descriptor sets used with the pipeline. A bitmask specifying options for pipeline creation. A pipeline to derive from. An index into the create infos parameter to use as a pipeline to derive from.

Structure specifying parameters of a newly created pipeline shader stage.

Specifies a single pipeline stage.

A object that contains the shader for this stage.

Unicode string specifying the entry point name of the shader for this stage.

Is null or a structure specifying specialization info.

Initializes a new instance of the structure.

Specifies a single pipeline stage. A object that contains the shader for this stage. Unicode string specifying the entry point name of the shader for this stage. Is null or a structure specifying specialization info.

Bitmask specifying a pipeline stage.

Specifies the vertex stage.

Specifies the tessellation control stage.

Specifies the tessellation evaluation stage.

Specifies the geometry stage.

Specifies the fragment stage.

Specifies the compute stage.

Is a combination of bits used as shorthand to specify all graphics stages defined above (excluding the compute stage).

Is a combination of bits used as shorthand to specify all shader stages supported by the device, including all additional stages which are introduced by extensions.

Structure specifying specialization info.

An array of which maps constant ids to offsets in .

The byte size of the buffer.

Contains the actual constant values to specialize with.

Initializes a new instasnce of the structure.

An array of which maps constant ids to offsets in . The byte size of the buffer. Contains the actual constant values to specialize with.

Structure specifying a specialization map entry.

The id of the specialization constant in SPIR-V.

The byte offset of the specialization constant value within the supplied data buffer.

The byte size of the specialization constant value within the supplied data buffer.

Initializes a new instance of the structure.

The id of the specialization constant in SPIR-V. The byte offset of the specialization constant value within the supplied data buffer. The byte size of the specialization constant value within the supplied data buffer.

Structure specifying parameters of a newly created pipeline vertex input state.

An array of structures.

Initializes a new instance of the structure.

An array of structures. An array of structures.

Structure specifying vertex input binding description.

The binding number that this structure describes.

The distance in bytes between two consecutive elements within the buffer.

Specifies whether vertex attribute addressing is a function of the vertex index or of the instance index.

Initializes a new instance of the structure.

The binding number that this structure describes. The distance in bytes between two consecutive elements within the buffer. Specifies whether vertex attribute addressing is a function of the vertex index or of the instance index.

Specify rate at which vertex attributes are pulled from buffers.

Specifies that vertex attribute addressing is a function of the vertex index.

Specifies that vertex attribute addressing is a function of the instance index.

Structure specifying vertex input attribute description.

The shader binding location number for this attribute. Must be less than .

The binding number which this attribute takes its data from. Must be less than .

The size and type of the vertex attribute data. Must be allowed as a vertex buffer format, as specified by the flag in returned by .

A byte offset of this attribute relative to the start of an element in the vertex input binding. Must be less than or equal to .

Initializes a new instance of the attribute.

The shader binding location number for this attribute. The binding number which this attribute takes its data from. The size and type of the vertex attribute data. A byte offset of this attribute relative to the start of an element in the vertex input binding.

Structure specifying parameters of a newly created pipeline input assembly state.

Defines the primitive topology.

Controls whether a special vertex index value is treated as restarting the assembly of primitives. This enable only applies to indexed draws ( and ), and the special index value is either 0xFFFFFFFF when the index type parameter of is equal to , or 0xFFFF when index type is equal to . Primitive restart is not allowed for "list" topologies.

Initializes a new instance of the structure.

Defines the primitive topology. Controls whether a special vertex index value is treated as restarting the assembly of primitives. This enable only applies to indexed draws ( and ), and the special index value is either 0xFFFFFFFF when the index type parameter of is equal to , or 0xFFFF when index type is equal to . Primitive restart is not allowed for "list" topologies.

Supported primitive topologies.

Structure specifying parameters of a newly created pipeline tessellation state.

Number of control points per patch. Must be greater than zero and less than or equal to .

Initializes a new instance of the structure.

Number of control points per patch.

Structure specifying parameters of a newly created pipeline viewport state.

Is or a pointer to an extension-specific structure.

An array of structures, defining the viewport transforms. If the viewport state is dynamic, this member is ignored.

An array of structures which define the rectangular bounds of the scissor for the corresponding viewport. If the scissor state is dynamic, this member is ignored.

Initializes a new instance of the structure.

An array of structures, defining the viewport transforms. If the viewport state is dynamic, this member is ignored. An array of structures which define the rectangular bounds of the scissor for the corresponding viewport. If the scissor state is dynamic, this member is ignored. Is or a pointer to an extension-specific structure.

Initializes a new instance of the structure.

Defines the viewport transforms. If the viewport state is dynamic, this member is ignored. Defines the rectangular bounds of the scissor for the viewport. If the scissor state is dynamic, this member is ignored. Is or a pointer to an extension-specific structure.

Structure specifying a viewport.

The x coordinate for the viewport's upper left corner (x,y).

The y coordinate for the viewport's upper left corner (x,y).

Viewport's width.

Viewport's height.

Minimum depth range for the viewport. It is valid for to be greater than or equal to . Must be between 0.0 and 1.0, inclusive.

Maximum depth range for the viewport. It is valid for to be greater than or equal to . Must be between 0.0 and 1.0, inclusive.

Initializes a new instance of the structure.

The x coordinate for the viewport's upper left corner (x,y). The y coordinate for the viewport's upper left corner (x,y). Viewport's width. Viewport's height. Minimum depth range for the viewport. It is valid for to be greater than or equal to . Maximum depth range for the viewport. It is valid for to be greater than or equal to .

Structure specifying parameters of a newly created pipeline rasterization state.

Is or a pointer to an extension-specific structure.

Controls whether to clamp the fragment's depth values instead of clipping primitives to the z planes of the frustum.

Controls whether primitives are discarded immediately before the rasterization stage.

The triangle rendering mode. See .

The triangle facing direction used for primitive culling. See .

Specifies the front-facing triangle orientation to be used for culling.

Controls whether to bias fragment depth values.

A scalar factor controlling the constant depth value added to each fragment.

The maximum (or minimum) depth bias of a fragment.

A scalar factor applied to a fragment's slope in depth bias calculations.

The width of rasterized line segments.

Bitmask controlling triangle culling.

Specifies that no triangles are discarded.

Specifies that front-facing triangles are discarded.

Specifies that back-facing triangles are discarded.

Specifies that all triangles are discarded.

Control polygon rasterization mode.

Specifies that polygons are rendered using the polygon rasterization rules in this section.

Specifies that polygon edges are drawn as line segments.

Specifies that polygon vertices are drawn as points.

Specifies that polygons are rendered using polygon rasterization rules, modified to consider a sample within the primitive if the sample location is inside the axis-aligned bounding box of the triangle after projection. Note that the barycentric weights used in attribute interpolation can extend outside the range [0,1] when these primitives are shaded. Special treatment is given to a sample position on the boundary edge of the bounding box. In such a case, if two rectangles lie on either side of a common edge (with identical endpoints) on which a sample position lies, then exactly one of the triangles must produce a fragment that covers that sample during rasterization. Polygons rendered in mode may be clipped by the frustum or by user clip planes. If clipping is applied, the triangle is culled rather than clipped. Area calculation and facingness are determined for mode using the triangle's vertices.

Interpret polygon front-facing orientation.

Specifies that a triangle with positive area is considered front-facing.

Specifies that a triangle with negative area is considered front-facing.

Structure specifying parameters of a newly created pipeline multisample state.

Specifies the number of samples per pixel used in rasterization.

Specifies that fragment shading executes per-sample if true, or per-fragment if false.

The minimum fraction of sample shading.

Bitmasks of static coverage information that is ANDed with the coverage information generated during rasterization. If not null, must be a an array of ` / 32` sample mask values.

Controls whether a temporary coverage value is generated based on the alpha component of the fragment's first color output.

Controls whether the alpha component of the fragment's first color output is replaced with one.

Structure specifying a pipeline color blend attachment state.

Controls whether blending is enabled for the corresponding color attachment. If blending is not enabled, the source fragment's color for that attachment is passed through unmodified.

Selects which blend factor is used to determine the source factors.

Selects which blend factor is used to determine the destination factors.

Selects which blend operation is used to calculate the RGB values to write to the color attachment.

Selects which blend factor is used to determine the source factor.

Selects which blend factor is used to determine the destination factor.

Selects which blend operation is use to calculate the alpha values to write to the color attachment.

A bitmask specifying which of the R, G, B, and/or A components are enabled for writing.

Bitmask controlling which components are written to the framebuffer.

Specifies that the R value is written to color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

Specifies that the G value is written to color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

Specifies that the B value is written to color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

Specifies that the A value is written to color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

Specifies that all the values are written to color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

Structure specifying parameters of a newly created pipeline color blend state.

Controls whether to apply logical operations.

Selects which logical operation to apply.

Per target attachment states.

R, G, B, and A components of the blend constant that are used in blending, depending on the blend factor.

Initializes a new instance of the structure.

Per target attachment states. Controls whether to apply logical operations. Selects which logical operation to apply. R, G, B, and A components of the blend constant that are used in blending, depending on the blend factor.

Framebuffer blending operations.

Stencil comparison function.

Keeps the current value.

Sets the value to 0.

Sets the value to reference.

Increments the current value and clamps to the maximum representable unsigned value.

Decrements the current value and clamps to 0.

Bitwise-inverts the current value.

Increments the current value and wraps to 0 when the maximum value would have been exceeded.

Decrements the current value and wraps to the maximum possible value when the value would go below 0.

Framebuffer logical operations.

Framebuffer blending factors.

Structure specifying parameters of a newly created pipeline depth stencil state.

Controls whether depth testing is enabled.

Controls whether depth writes are enabled when is true. Depth writes are always disabled when is false.

The comparison operator used in the depth test.

Controls whether depth bounds testing is enabled.

Controls whether stencil testing is enabled.

Controls the parameters of the stencil test.

Defines the range of values used in the depth bounds test.

Structure specifying stencil operation state.

Specifies the action performed on samples that fail the stencil test.

Specifies the action performed on samples that pass both the depth and stencil tests.

Specifies the action performed on samples that pass the stencil test and fail the depth test.

Specifies the comparison operator used in the stencil test.

Selects the bits of the unsigned integer stencil values participating in the stencil test.

Selects the bits of the unsigned integer stencil values updated by the stencil test in the stencil framebuffer attachment.

An integer reference value that is used in the unsigned stencil comparison.

Stencil comparison function.

Specifies that the test never passes.

Specifies that the test passes when R < S.

Specifies that the test passes when R = S.

Specifies that the test passes when R <= S.

Specifies that the test passes when R > S.

Specifies that the test passes when R != S.

Specifies that the test passes when R >= S.

Specifies that the test always passes.

Structure specifying parameters of a newly created pipeline dynamic state.

Values specifying which pieces of pipeline state will use the values from dynamic state commands rather than from the pipeline state creation info.

Initializes a new instance of the structure.

Values specifying which pieces of pipeline state will use the values from dynamic state commands rather than from the pipeline state creation info.

Indicate which dynamic state is taken from dynamic state commands.

Specifies that the state will be ignored and must be set dynamically with before any draw commands. The number of viewports used by a pipeline is still specified by the length of .

Specifies that the state will be ignored and must be set dynamically with before any draw commands. The number of scissor rectangles used by a pipeline is still specified by the length of .

Specifies that the state will be ignored and must be set dynamically with before any draw commands that generate line primitives for the rasterizer.

Specifies that the , and states will be ignored and must be set dynamically with before any draws are performed with set to true.

Specifies that the state will be ignored and must be set dynamically with before any draws are performed with a pipeline state with member set to true and any of the blend functions using a constant blend color.

Specifies that the and states will be ignored and must be set dynamically with before any draws are performed with a pipeline state with member set to true.

Specifies that the compare mask state in both and will be ignored and must be set dynamically with before any draws are performed with a pipeline state with member set to true.

Specifies that the write mask state in both and will be ignored and must be set dynamically with before any draws are performed with a pipeline state with member set to true.

Specifies that the reference state in both and will be ignored and must be set dynamically with before any draws are performed with a pipeline state with member set to true.

Specifies that the state will be ignored and must be set dynamically with before any draws are performed with a pipeline state with set to true.

Opaque handle to a pipeline cache object. Pipeline cache objects allow the result of pipeline construction to be reused between pipelines and between runs of an application. Reuse between pipelines is achieved by passing the same pipeline cache object when creating multiple related pipelines. Reuse across runs of an application is achieved by retrieving pipeline cache contents in one run of an application, saving the contents, and using them to preinitialize a pipeline cache on a subsequent run. The contents of the pipeline cache objects are managed by the implementation. Applications can manage the host memory consumed by a pipeline cache object and control the amount of data retrieved from a pipeline cache object.

Gets the parent of the resource.

Get the data store from a pipeline cache.

Buffer. Vulkan returns an error code.

Combine the data stores of pipeline caches.

Pipeline cache to merge into this.

Combine the data stores of pipeline caches.

Pipeline caches to merge into this.

Destroy a pipeline cache object.

Structure specifying parameters of a newly created pipeline cache.

Previously retrieved pipeline cache data. If the pipeline cache data is incompatible with the device, the pipeline cache will be initially empty. If length is zero, is ignored.

Initializes a new instance of the structure.

Previously retrieved pipeline cache data. If the pipeline cache data is incompatible with the device, the pipeline cache will be initially empty. If length is zero, is ignored.

Encode pipeline cache version.

Specifies version one of the pipeline cache.

Opaque handle to a pipeline layout object. Access to descriptor sets from a pipeline is accomplished through a pipeline layout. Zero or more descriptor set layouts and zero or more push constant ranges are combined to form a pipeline layout object which describes the complete set of resources that can be accessed by a pipeline. The pipeline layout represents a sequence of descriptor sets with each having a specific layout. This sequence of layouts is used to determine the interface between shader stages and shader resources. Each pipeline is created using a pipeline layout.

Gets the parent of the resource.

Destroy a pipeline layout object.

Structure specifying the parameters of a newly created pipeline layout object.

An array of objects.

Structures defining a set of push constant ranges for use in a single pipeline layout. In addition to descriptor set layouts, a pipeline layout also describes how many push constants can be accessed by each stage of the pipeline. Push constants represent a high speed path to modify constant data in pipelines that is expected to outperform memory-backed resource updates.

Initializes a new instance of the structure.

An array of objects. Structures defining a set of push constant ranges for use in a single pipeline layout. In addition to descriptor set layouts, a pipeline layout also describes how many push constants can be accessed by each stage of the pipeline. Push constants represent a high speed path to modify constant data in pipelines that is expected to outperform memory-backed resource updates.

Structure specifying a push constant range.

The start offset consumed by the range. Offset is in units of bytes and must be a multiple of 4. The layout of the push constant variables is specified in the shader.

The size consumed by the range. Size is in units of bytes and must be a multiple of 4. The layout of the push constant variables is specified in the shader.

Initializes a new instance of the structure.

A set of stage flags describing the shader stages that will access a range of push constants. If a particular stage is not included in the range, then accessing members of that range of push constants from the corresponding shader stage will result in undefined data being read. The start offset consumed by the range. Offset is in units of bytes and must be a multiple of 4. The layout of the push constant variables is specified in the shader. The size consumed by the range. Size is in units of bytes and must be a multiple of 4. The layout of the push constant variables is specified in the shader.

Opaque handle to a query pool object. Queries are managed using query pool objects. Each query pool is a collection of a specific number of queries of a particular type.

Gets the parent of the resource.

Copy results of queries in a query pool to a host memory region.

The initial query index. The number of queries. and together define a range of queries. The size in bytes of the buffer pointed to by . A pointer to a user-allocated buffer where the results will be written. The stride in bytes between results for individual queries within . A bitmask specifying how and when results are returned.

Destroy a query pool object.

Structure specifying parameters of a newly created query pool.

Specifies the type of queries managed by the pool.

The number of queries managed by the pool.

A bitmask specifying which counters will be returned in queries on the new pool. Ignored if is not .

Initializes a new instance of the structure.

Specifies the type of queries managed by the pool. The number of queries managed by the pool. A bitmask specifying which counters will be returned in queries on the new pool. Ignored if is not .

Specify the type of queries managed by a query pool.

Specifies an occlusion query.

Specifies a pipeline statistics query.

Specifies a timestamp query.

Bitmask specifying how and when query results are returned.

No flags.

Specifies the results will be written as an array of 64-bit unsigned integer values. If this bit is not set, the results will be written as an array of 32-bit unsigned integer values.

Specifies that Vulkan will wait for each query's status to become available before retrieving its results.

Specifies that the availability status accompanies the results.

Specifies that returning partial results is acceptable.

Opaque handle to a queue object.

Gets the parent of the resource.

Gets the queue family index.

Gets the queue index.

Submits a sequence of semaphores or command buffers to a queue.

Structures, each specifying a command buffer submission batch. An optional handle to a fence to be signaled. If fence is not null, it defines a fence signal operation. Vulkan returns an error code.

Submits a sequence of semaphores or command buffers to a queue.

Specifies a command buffer submission batch. An optional handle to a fence to be signaled. If fence is not null, it defines a fence signal operation. Vulkan returns an error code.

Submits semaphores or a command buffer to a queue.

An optional handle to a fence to be signaled. If fence is not null, it defines a fence signal operation. Semaphore upon which to wait before the command buffer for this batch begins execution. If semaphore to wait on is provided, it defines a semaphore wait operation. Pipeline stages at which semaphore wait will occur. Command buffer to execute in the batch. Semaphore which will be signaled when the command buffer for this batch has completed execution. If semaphore to be signaled is provided, it defines a semaphore signal operation. Vulkan returns an error code.

Wait for a queue to become idle. Equivalent to submitting a fence to a queue and waiting with an infinite timeout for that fence to signal.

Vulkan returns an error code.

Bind device memory to a sparse resource object.

Specifying a sparse binding submission batch. An optional handle to a fence to be signaled. If fence is not null, it defines a fence signal operation. Vulkan returns an error code.

Bind device memory to a sparse resource object.

An array of structures, each specifying a sparse binding submission batch. An optional handle to a fence to be signaled. If fence is not null, it defines a fence signal operation. Vulkan returns an error code.

Structure specifying a queue submit operation.

Semaphores upon which to wait before the command buffers for this batch begin execution. If semaphores to wait on are provided, they define a semaphore wait operation.

Pipeline stages at which each corresponding semaphore wait will occur.

Command buffers to execute in the batch.

Semaphores which will be signaled when the command buffers for this batch have completed execution. If semaphores to be signaled are provided, they define a semaphore signal operation.

Initializes a new instance of the structure.

Semaphores upon which to wait before the command buffers for this batch begin execution. If semaphores to wait on are provided, they define a semaphore wait operation. Pipeline stages at which each corresponding semaphore wait will occur. Command buffers to execute in the batch. The command buffers submitted in a batch begin execution in the order they appear in , but may complete out of order. Semaphores which will be signaled when the command buffers for this batch have completed execution. If semaphores to be signaled are provided, they define a semaphore signal operation.

Structure specifying a sparse binding operation.

Semaphores upon which to wait on before the sparse binding operations for this batch begin execution. If semaphores to wait on are provided, they define a semaphore wait operation.

An array of structures.

An array of structures, indicating opaque sparse image bindings to perform.

An array of structures, indicating sparse image bindings to perform.

Semaphores which will be signaled when the sparse binding operations for this batch have completed execution. If semaphores to be signaled are provided, they define a semaphore signal operation.

Initializes a new instance of the structure.

Semaphores upon which to wait on before the sparse binding operations for this batch begin execution. If semaphores to wait on are provided, they define a semaphore wait operation. An array of structures. An array of structures, indicating opaque sparse image bindings to perform. An array of structures, indicating sparse image bindings to perform. Semaphores which will be signaled when the sparse binding operations for this batch have completed execution. If semaphores to be signaled are provided, they define a semaphore signal operation.

Structure specifying a sparse buffer memory bind operation.

The object to be bound.

An array of structures.

Initializes a new instance of the structure.

The object to be bound. An array of structures.

Structure specifying a sparse memory bind operation.

The offset into the resource.

The size of the memory region to be bound.

The object that the range of the resource is bound to. If memory 0, the range is unbound.

The offset into the object to bind the resource range to. If memory is 0, this value is ignored.

A bitmask specifying usage of the binding operation.

Initializes a new instance of the structure.

The offset into the resource. The size of the memory region to be bound. The object that the range of the resource is bound to. If memory 0, the range is unbound. The offset into the object to bind the resource range to. If memory is 0, this value is ignored. A bitmask specifying usage of the binding operation.

Bitmask specifying usage of a sparse memory binding operation.

No flags.

Specifies that the memory being bound is only for the metadata aspect.

Structure specifying sparse image opaque memory bind info.

The object to be bound.

An array of structures. Length must be greater than 0.

Initializes a new instance of the structure.

The object to be bound. An array of structures.

Structure specifying sparse image memory bind info.

The object to be bound.

An array of structures. Length must be greater than 0.

Initializes a new instance of the structure.

The object to be bound. An array of structures.

Structure specifying sparse image memory bind.

The aspect mask and region of interest in the image. Must be a valid subresource for .

The coordinates of the first texel within the image subresource to bind.

The size in texels of the region within the image subresource to bind. The extent must be a multiple of the sparse image block dimensions, except when binding sparse image blocks along the edge of an image subresource it can instead be such that any coordinate of + equals the corresponding dimensions of the image subresource.

The object that the sparse image blocks of the image are bound to. If memory is 0, the sparse image blocks are unbound. Must match the memory requirements of the calling command's .

An offset into object. If memory is 0, this value is ignored. Must match the memory requirements of the calling command's .

Sparse memory binding flags.

Structure specifying a two-dimensional subregion.

A with all of its components set to zero.

The offset component of the rectangle.

The extent component of the rectangle.

Initializes a new instance of the structure.

The offset component of the rectangle. The extent component of the rectangle.

Initializes a new instance of the structure.

The X component of the offset. The Y component of the offset. The width component of the extent. The height component of the extent.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns the hash code for this instance.

The hash code.

Returns a boolean indicating whether the two given rectangles are equal.

The first rectangle to compare. The second rectangle to compare. true if the rectangles are equal; false otherwise.

Returns a boolean indicating whether the two given rectangles are not equal.

The first rectangle to compare. The second rectangle to compare. true if the rectangles are not equal; false if they are equal.

Structure specifying a three-dimensional subregion.

A with all of its components set to zero.

The offset component of the cuboid.

The extent component of the cuboid.

Initializes a new instance of the structure.

The offset component of the rectangle. The extent component of the rectangle.

Initializes a new instance of the structure.

The X component of the offset. The Y component of the offset. The Z component of the offset. The width component of the extent. The height component of the extent. The depth component of the extent.

Returns a string representing this instance.

The string representation.

Returns a string representing this instance, using the specified format to format individual elements and the given .

The format provider to use when formatting elements. The string representation.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns the hash code for this instance.

The hash code.

Returns a boolean indicating whether the two given rectangles are equal.

The first rectangle to compare. The second rectangle to compare. true if the rectangles are equal; false otherwise.

Returns a boolean indicating whether the two given rectangles are not equal.

The first rectangle to compare. The second rectangle to compare. true if the rectangles are not equal; false if they are equal.

Opaque handle to a render pass object. A render pass represents a collection of attachments, subpasses, and dependencies between the subpasses, and describes how the attachments are used over the course of the subpasses. The use of a render pass in a command buffer is a render pass instance.

Gets the parent of the resource.

Returns the granularity for optimal render area.

The structure in which the granularity is returned.

Create a new framebuffer object.

The structure which describes additional information about framebuffer creation. Controls host memory allocation. The resulting framebuffer object. Vulkan returns an error code.

Destroy a render pass object.

Structure specifying parameters of a newly created render pass.

Structures describing properties of the attachments, or null.

Structures describing properties of the subpasses.

Structures describing dependencies between pairs of subpasses, or null.

Initializes a new instnace of the structure.

Structures describing properties of the subpasses. Structures describing properties of the attachments, or null. Structures describing dependencies between pairs of subpasses, or null.

Structure specifying a subpass description.

A bitmask specifying usage of the subpass.

Structures that lists which of the render pass's attachments will be used as color attachments in the subpass, and what layout each attachment will be in during the subpass. Each element of the array corresponds to a fragment shader output location, i.e. if the shader declared an output variable layout(location=X) then it uses the attachment provided in ColorAttachments[X].

Structures that lists which of the render pass's attachments can be read in the shader during the subpass, and what layout each attachment will be in during the subpass. Each element of the array corresponds to an input attachment unit number in the shader, i.e. if the shader declares an input variable layout(inputAttachmentIndex=X, set=Y, binding=Z then it uses the attachment provided in InputAttachments[X]. Input attachments must also be bound to the pipeline with a descriptor set, with the input attachment descriptor written in the location (set=Y, binding=Z).

Is null or an array of structures that lists which of the render pass's attachments are resolved to at the end of the subpass, and what layout each attachment will be in during the multisample resolve operation. If is not null, each of its elements corresponds to a color attachment (the element in at the same index), and a multisample resolve operation is defined for each attachment. At the end of each subpass, multisample resolve operations read the subpass's color attachments, and resolve the samples for each pixel to the same pixel location in the corresponding resolve attachments, unless the resolve attachment index is . If the first use of an attachment in a render pass is as a resolve attachment, then the is effectively ignored as the resolve is guaranteed to overwrite all pixels in the render area.

Specifies which attachment will be used for depth/stencil data and the layout it will be in during the subpass. Setting the attachment index to or leaving this as null indicates that no depth/stencil attachment will be used in the subpass.

Render pass attachment indices describing the attachments that are not used by a subpass, but whose contents must be preserved throughout the subpass.

Initializes a new instance of the structure.

A bitmask indicating usage of the subpass. Structures that lists which of the render pass’s attachments will be used as color attachments in the subpass, and what layout each attachment will be in during the subpass. Each element of the array corresponds to a fragment shader output location, i.e. if the shader declared an output variable layout(location=X) then it uses the attachment provided in ColorAttachments[X]. Structures that lists which of the render pass's attachments can be read in the shader during the subpass, and what layout each attachment will be in during the subpass. Each element of the array corresponds to an input attachment unit number in the shader, i.e. if the shader declares an input variable layout(inputAttachmentIndex=X, set=Y, binding=Z) then it uses the attachment provided in InputAttachments[X]. Input attachments must also be bound to the pipeline with a descriptor set, with the input attachment descriptor written in the location (set=Y, binding=Z). Is null or an array of structures that lists which of the render pass's attachments are resolved to at the end of the subpass, and what layout each attachment will be in during the multisample resolve operation. If is not null, each of its elements corresponds to a color attachment (the element in at the same index), and a multisample resolve operation is defined for each attachment. At the end of each subpass, multisample resolve operations read the subpass's color attachments, and resolve the samples for each pixel to the same pixel location in the corresponding resolve attachments, unless the resolve attachment index is . If the first use of an attachment in a render pass is as a resolve attachment, then the is effectively ignored as the resolve is guaranteed to overwrite all pixels in the render area. Specifies which attachment will be used for depth/stencil data and the layout it will be in during the subpass. Setting the attachment index to or leaving this as null indicates that no depth/stencil attachment will be used in the subpass. Render pass attachment indices describing the attachments that are not used by a subpass, but whose contents must be preserved throughout the subpass.

Initializes a new instance of the structure.

Structures that lists which of the render pass’s attachments will be used as color attachments in the subpass, and what layout each attachment will be in during the subpass. Each element of the array corresponds to a fragment shader output location, i.e. if the shader declared an output variable layout(location=X) then it uses the attachment provided in [X]. Specifies which attachment will be used for depth/stencil data and the layout it will be in during the subpass. Setting the attachment index to or leaving this as null indicates that no depth/stencil attachment will be used in the subpass.

Bitmask specifying usage of a subpass.

No flags.

Specifies that shaders compiled for this subpass write the attributes for all views in a single invocation of each vertex processing stage. All pipelines compiled against a subpass that includes this bit must write per-view attributes to the *PerViewNV[] shader outputs, in addition to the non-per-view (e.g. Position) outputs.

Specifies that shaders compiled for this subpass use per-view positions which only differ in value in the x component. Per-view viewport mask can also be used.

Specify the bind point of a pipeline object to a command buffer. There are separate bind points for each of graphics and compute, so binding one does not disturb the other.

Specifies binding as a graphics pipeline.

Specifies binding as a compute pipeline.

Structure specifying an attachment reference.

The index of the attachment of the render pass, and corresponds to the index of the corresponding element in the array. If any color or depth/stencil attachments are , then no writes occur for those attachments.

Specifies the layout the attachment uses during the subpass. Must not be or .

Initializes a new instance of the structure.

Structure specifying a subpass dependency.

The subpass index of the first subpass in the dependency, or .

The subpass index of the second subpass in the dependency, or .

Specifies a source stage mask.

Specifies a destination stage mask.

Specifies a source access mask.

Specifies a destination access mask.

A bitmask of .

Bitmask specifying how execution and memory dependencies are formed.

No flags.

Specifies that dependencies will be framebuffer-local.

Specifies that a subpass has more than one view.

Specifies that dependencies are non-device-local.

Vulkan command return codes.

Command successfully completed.

A fence or query has not yet completed.

A wait operation has not completed in the specified time.

An event is signaled.

An event is unsignaled.

A return array was too small for the result.

A host memory allocation has failed.

A device memory allocation has failed.

Initialization of an object could not be completed for implementation-specific reasons.

The logical or physical device has been lost.

Mapping of a memory object has failed.

A requested layer is not present or could not be loaded.

A requested extension is not supported.

A requested feature is not supported.

The requested version of Vulkan is not supported by the driver or is otherwise incompatible for implementation-specific reasons.

Too many objects of the type have already been created.

A requested format is not supported on this device.

A pool allocation has failed due to fragmentation of the pool's memory. This must only be returned if no attempt to allocate host or device memory was made to accomodate the new allocation.

The surface becomes no longer available.

The requested window is already in use by Vulkan or another API in a manner which prevents it from being used again.

A swapchain no longer matches the surface properties exactly, but can still be used to present to the surface successfully.

A surface has changed in such a way that it is no longer compatible with the swapchain, and further presentation requests using the swapchain will fail. Applications must query the new surface properties and recreate their swapchain if they wish to continue presenting to the surface.

The application returned true from its callback and the Vulkan call being aborted returned a .

One or more shaders failed to compile or link. More details are reported back to the application via if enabled.

A pool memory allocation has failed. This must only be returned if no attempt to allocate host or device memory was made to accomodate the new allocation. If the failure was definitely due to fragmentation of the pool, should be returned instead.

An external handle is not a valid handle of the specified type.

Opaque handle to a sampler object. objects represent the state of an image sampler which is used by the implementation to read image data and apply filtering and other transformations for the shader.

Gets the parent of the resource.

Destroy a sampler object.

Structure specifying parameters of a newly created sampler.

Specifies the magnification filter to apply to lookups.

Specifies the minification filter to apply to lookups.

Specifies the mipmap filter to apply to lookups.

Specifies the addressing mode for outside [0..1] range for U coordinate.

Specifies the addressing mode for outside [0..1] range for V coordinate.

Specifies the addressing mode for outside [0..1] range for W coordinate.

The bias to be added to mipmap LOD calculation and bias provided by image sampling functions in SPIR-V.

Is true to enable anisotropic filtering, or false otherwise.

The anisotropy value clamp.

Is true to enable comparison against a reference value during lookups, or false otherwise.

Specifies the comparison function to apply to fetched data before filtering.

The value used to clamp the computed level-of-detail value. Must be less than or equal to .

The value used to clamp the computed level-of-detail value. Must be greater than or equal to .

Specifies the predefined border color to use.

Controls whether to use unnormalized or normalized texel coordinates to address texels of the image. When set to true, the range of the image coordinates used to lookup the texel is in the range of zero to the image dimensions for x, y and z. When set to false the range of image coordinates is zero to one.

Specify mipmap mode used for texture lookups.

Specifies nearest filtering.

Specifies linear filtering.

Specify behavior of sampling with texture coordinates outside an image.

Specifies that the repeat wrap mode will be used.

Specifies that the mirrored repeat wrap mode will be used.

Specifies that the clamp to edge wrap mode will be used.

Specifies that the clamp to border wrap mode will be used.

Specifies that the mirror clamp to edge wrap mode will be used. This is only valid if the "VK_KHR_mirror_clamp_to_edge" extension is enabled.

Specify border color used for texture lookups.

Specifies a transparent, floating-point format, black color.

Specifies a transparent, integer format, black color.

Specifies an opaque, floating-point format, black color.

Specifies an opaque, integer format, black color.

Specifies an opaque, floating-point format, white color.

Specifies an opaque, integer format, white color.

Opaque handle to a semaphore object. Semaphores are a synchronization primitive that can be used to insert a dependency between batches submitted to queues. Semaphores have two states - signaled and unsignaled. The state of a semaphore can be signaled after execution of a batch of commands is completed. A batch can wait for a semaphore to become signaled before it begins execution, and the semaphore is also unsignaled before the batch begins execution.

Gets the parent of this resource.

Destroy a semaphore object.

Structure specifying parameters of a newly created semaphore.

Opaque handle to a shader module object. Shader modules contain shader code and one or more entry points. Shaders are selected from a shader module by specifying an entry point as part of pipeline creation. The stages of a pipeline can use shaders that come from different modules. The shader code defining a shader module must be in the SPIR-V format.

Gets the owner of the resource.

Destroy a shader module.

Structure specifying parameters of a newly created shader module.

The code that is used to create the shader module. The type and format of the code is determined from the content of the code.

Initializes a new instance of the structure.

The code that is used to create the shader module. The type and format of the code is determined from the content of the code.

A platform-specific type that is used to represent a size (in bytes) of an object in memory. Equivalent to C/C++ size_t type.

Initializes a new instance of the structure.

The size of an object in bytes.

Initializes a new instance of the structure.

The size of an object in bytes.

Converts the numeric value of the current object to its equivalent string representation.

The string representation of the value of this instance.

Returns a boolean indicating whether the given is equal to this instance.

The to compare this instance to. true if the other is equal to this instance; false otherwise.

Returns a boolean indicating whether the given is equal to this instance.

The to compare against. true if the is equal to this instance; false otherwise.

Returns the hash code for this instance.

The hash code.

Compares the current instance with another size and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other version.

A size to compare with this instance. A value that indicates the relative order of the sizes being compared.

Returns a boolean indicating whether the two given sizes are equal.

The first size to compare. The second size to compare. true if the sizes are equal; false otherwise.

Returns a boolean indicating whether the two given sizes are not equal.

The first size to compare. The second size to compare. true if the sizes are not equal; false if they are equal.

Implicitly converts an to a .

Instance to convert.

Implicitly converts a to a .

Instance to convert.

Implicitly converts an to a .

Instance to convert.

Explicitly converts a to an .

Instance to convert.

Implicitly converts a to a .

Instance to convert.

Implicitly converts a to an .

Instance to convert.

Structure type enumerant.

Reserved for internal use by the loader, layers, and ICDs.

Provides helper methods for various types.

Gets the index of the that has all the requested set or -1 if not found.

Structures describing the memory types that can be used to access memory allocated from the heaps specified by . A bitmask of that contains one bit set for every memory type supported by the resource. A bitmask of properties to request. Index of the requested or -1 if not found. /// is null.

Determines whether a sequence of contains a layer with specified .

A sequence in which to locate a layer name. The layer name to locate in the sequence. true if the source sequence contains an element that has the specified value; otherwise, false. is null.

Determines whether a sequence of contains a layer with specified .

A sequence in which to locate an extension name. The layer name to locate in the sequence. true if the source sequence contains an element that has the specified value; otherwise, false. is null.

Semantic Versioning number.

http://semver.org/

Initializes a new instance of the struct.

Major component of semver. Minor component of semver. Patch component of semver.

Gets the major component of semver.

Gets the minor component of semver.

Gets the patch component of semver.

Returns a string that represents the current version in the form of MAJOR.MINOR.PATCH.

A string that represents the current version.

Indicates whether the current version is equal to another version.

A version to compare with this version. true if the current version is equal to the other parameter; otherwise, false.

Compares the current instance with another version and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other version.

A version to compare with this instance. A value that indicates the relative order of the versions being compared.

A shorthand for writing new Version(0, 0, 0).

Represents an error from executing a Vulkan command.

Initializes a new instance of the class.

The result returned by Vulkan. The message that describes the error.

Gets the result returned by Vulkan.

Gets if the result is considered an error.