+fun codeBlock(code: String) = """
${code
.replace(CODE_BLOCK_TRIM_PATTERN, "") // ...trim
.replace(CODE_BLOCK_ESCAPE_PATTERN, "\uFFFF") // ...escape
.replace(CODE_BLOCK_TAB_PATTERN, " ") // ...replace with 4 spaces for consistent formatting.
-}typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
+
+typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
@@ -109,7 +110,7 @@ val PFN_vkDebugReportCallbackEXT = "PFN_vkDebugReportCallbackEXT".callback(
int32_t messageCode,
const char* pLayerPrefix,
const char* pMessage,
- void* pUserData);typedef enum VkDebugReportObjectTypeEXT {
+
+typedef enum VkDebugReportObjectTypeEXT {
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
@@ -153,7 +155,7 @@ val PFN_vkDebugReportCallbackEXT = "PFN_vkDebugReportCallbackEXT".callback(
VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
-} VkDebugReportObjectTypeEXT;typedef enum VkSwapchainCreateFlagBitsKHR {
+
+typedef enum VkSwapchainCreateFlagBitsKHR {
VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
-} VkSwapchainCreateFlagBitsKHR;typedef enum VkDebugReportFlagBitsEXT {
+
+typedef enum VkDebugReportFlagBitsEXT {
VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
-} VkDebugReportFlagBitsEXT;typedef enum VkMemoryAllocateFlagBitsKHX {
+
+typedef enum VkMemoryAllocateFlagBitsKHX {
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001,
-} VkMemoryAllocateFlagBitsKHX;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.", size = "VK_MAX_DEVICE_GROUP_SIZE_KHX")
VkDeviceGroupPresentModeFlagsKHX.member("modes", """a bitmask indicating which device group presentation modes are supported. The bits returned in {@code modes} are:
-typedef enum VkDeviceGroupPresentModeFlagBitsKHX {
+
+typedef enum VkDeviceGroupPresentModeFlagBitsKHX {
VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001,
VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002,
VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004,
VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008,
-} VkDeviceGroupPresentModeFlagBitsKHX;typedef enum VkValidationCheckEXT {
+
+typedef enum VkValidationCheckEXT {
VK_VALIDATION_CHECK_ALL_EXT = 0,
-} VkValidationCheckEXT;typedef enum VkExternalMemoryHandleTypeFlagBitsKHX {
+
+typedef enum VkExternalMemoryHandleTypeFlagBitsKHX {
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
@@ -1799,7 +1807,7 @@ val VkPhysicalDeviceExternalImageFormatInfoKHX = struct(VULKAN_PACKAGE, "VkPhysi
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 0x00000010,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 0x00000020,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 0x00000040,
-} VkExternalMemoryHandleTypeFlagBitsKHX;typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHX {
+
+typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHX {
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 0x00000008,
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 0x00000010,
-} VkExternalSemaphoreHandleTypeFlagBitsKHX;typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
+
+typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
-} VkIndirectCommandsLayoutUsageFlagBitsNVX;void cmdProcessAllSequences(cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, sequencesCount, indexbuffer, indexbufferoffset)
-{
+
+void cmdProcessAllSequences(cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, sequencesCount, indexbuffer, indexbufferoffset)
+{
for (s = 0; s < sequencesCount; s++)
{
sequence = s;
@@ -2653,7 +2664,7 @@ val VkIndirectCommandsLayoutCreateInfoNVX = struct(VULKAN_PACKAGE, "VkIndirectCo
cmdProcessSequence( cmd, objectTable, indirectCommandsLayout, pIndirectCommandsTokens, sequence );
}
-}typedef enum VkObjectEntryTypeNVX {
+
+typedef enum VkObjectEntryTypeNVX {
VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0,
VK_OBJECT_ENTRY_PIPELINE_NVX = 1,
VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2,
VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3,
VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4,
-} VkObjectEntryTypeNVX;typedef enum VkObjectEntryUsageFlagBitsNVX {
+
+typedef enum VkObjectEntryUsageFlagBitsNVX {
VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
-} VkObjectEntryUsageFlagBitsNVX;typedef enum VkDisplayPowerStateEXT {
+
+typedef enum VkDisplayPowerStateEXT {
VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
VK_DISPLAY_POWER_STATE_ON_EXT = 2,
-} VkDisplayPowerStateEXT;typedef enum VkDisplayEventTypeEXT {
+
+typedef enum VkDisplayEventTypeEXT {
VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
-} VkDisplayEventTypeEXT;typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
+
+typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
void* pUserData,
size_t size,
size_t alignment,
- VkSystemAllocationScope allocationScope);typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
+
+typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
void* pUserData,
void* pOriginal,
size_t size,
size_t alignment,
- VkSystemAllocationScope allocationScope);min(original size, new size) - 1 must be preserved in the returned allocation. If {@code size} 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.
@@ -260,9 +262,10 @@ val PFN_vkFreeFunction = "PFN_vkFreeFunction".callback(
typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
+
+typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
void* pUserData,
- void* pMemory);typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
+
+typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
void* pUserData,
size_t size,
VkInternalAllocationType allocationType,
- VkSystemAllocationScope allocationScope);typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
+
+typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
void* pUserData,
size_t size,
VkInternalAllocationType allocationType,
- VkSystemAllocationScope allocationScope);typedef enum VkFormatFeatureFlagBits {
+
+typedef enum VkFormatFeatureFlagBits {
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
@@ -688,7 +694,7 @@ val VkFormatProperties = struct(VULKAN_PACKAGE, "VkFormatProperties", mutable =
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
-} VkFormatFeatureFlagBits;typedef enum VkSampleCountFlagBits {
+
+typedef enum VkSampleCountFlagBits {
VK_SAMPLE_COUNT_1_BIT = 0x00000001,
VK_SAMPLE_COUNT_2_BIT = 0x00000002,
VK_SAMPLE_COUNT_4_BIT = 0x00000004,
@@ -813,7 +820,7 @@ val VkPhysicalDeviceLimits = struct(VULKAN_PACKAGE, "VkPhysicalDeviceLimits", mu
VK_SAMPLE_COUNT_16_BIT = 0x00000010,
VK_SAMPLE_COUNT_32_BIT = 0x00000020,
VK_SAMPLE_COUNT_64_BIT = 0x00000040,
-} VkSampleCountFlagBits;typedef enum VkQueueFlagBits {
+
+typedef enum VkQueueFlagBits {
VK_QUEUE_GRAPHICS_BIT = 0x00000001,
VK_QUEUE_COMPUTE_BIT = 0x00000002,
VK_QUEUE_TRANSFER_BIT = 0x00000004,
VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
-} VkQueueFlagBits;typedef enum VkMemoryPropertyFlagBits {
+
+typedef enum VkMemoryPropertyFlagBits {
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
-} VkMemoryPropertyFlagBits;typedef enum VkMemoryHeapFlagBits {
+
+typedef enum VkMemoryHeapFlagBits {
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
-} VkMemoryHeapFlagBits;(X {leq} Y) {land} {lnot} (Y {leq} X) according to the preorder. Note that the list of all allowed memory property flag combinations above satisfies this preorder, but other orders would as well. The goal of this ordering is to enable applications to use a simple search loop in selecting the proper memory type, along the lines of:
- // Find a memory type in "memoryTypeBits" that includes all of "properties"
-int32_t FindProperties(uint32_t memoryTypeBits, VkMemoryPropertyFlags properties)
-{
+
+// Find a memory type in "memoryTypeBits" that includes all of "properties"
+int32_t FindProperties(uint32_t memoryTypeBits, VkMemoryPropertyFlags properties)
+{
for (int32_t i = 0; i < memoryTypeCount; ++i)
{
if ((memoryTypeBits & (1 << i)) &&
@@ -1137,15 +1148,15 @@ int32_t FindProperties(uint32_t memoryTypeBits, VkMemoryPropertyFlags properties
return i;
}
return -1;
-}
+}
-// Try to find an optimal memory type, or if it does not exist
-// find any compatible memory type
-VkMemoryRequirements memoryRequirements;
-vkGetImageMemoryRequirements(device, image, &memoryRequirements);
-int32_t memoryType = FindProperties(memoryRequirements.memoryTypeBits, optimalProperties);
-if (memoryType == -1)
- memoryType = FindProperties(memoryRequirements.memoryTypeBits, requiredProperties);typedef enum VkSparseImageFormatFlagBits {
+
+typedef enum VkSparseImageFormatFlagBits {
VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
-} VkSparseImageFormatFlagBits;typedef enum VkSparseMemoryBindFlagBits {
+
+typedef enum VkSparseMemoryBindFlagBits {
VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
-} VkSparseMemoryBindFlagBits;typedef enum VkFenceCreateFlagBits {
+
+typedef enum VkFenceCreateFlagBits {
VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
-} VkFenceCreateFlagBits;typedef enum VkQueryType {
+
+typedef enum VkQueryType {
VK_QUERY_TYPE_OCCLUSION = 0,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
VK_QUERY_TYPE_TIMESTAMP = 2,
-} VkQueryType;typedef enum VkBufferUsageFlagBits {
+
+typedef enum VkBufferUsageFlagBits {
VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
@@ -1789,7 +1805,7 @@ val VkBufferCreateInfo = struct(VULKAN_PACKAGE, "VkBufferCreateInfo") {
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
-} VkBufferUsageFlagBits;typedef enum VkBufferCreateFlagBits {
+
+typedef enum VkBufferCreateFlagBits {
VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
-} VkBufferCreateFlagBits;// (x,y,z,layer) are in texel coordinates
-address(x,y,z,layer) = layer*arrayPitch + z*depthPitch + y*rowPitch + x*elementSize + offset
+// (x,y,z,layer) are in texel coordinates
+address(x,y,z,layer) = layer*arrayPitch + z*depthPitch + y*rowPitch + x*elementSize + offset
// (x,y,z,layer) are in compressed texel block coordinates
-address(x,y,z,layer) = layer*arrayPitch + z*depthPitch + y*rowPitch + x*compressedTexelBlockByteSize + offset;
+// (x,y,z,layer) are in compressed texel block coordinates
+address(x,y,z,layer) = layer*arrayPitch + z*depthPitch + y*rowPitch + x*compressedTexelBlockByteSize + offset;
typedef enum VkComponentSwizzle {
+
+typedef enum VkComponentSwizzle {
VK_COMPONENT_SWIZZLE_IDENTITY = 0,
VK_COMPONENT_SWIZZLE_ZERO = 1,
VK_COMPONENT_SWIZZLE_ONE = 2,
@@ -2071,7 +2091,7 @@ val VkComponentMapping = struct(VULKAN_PACKAGE, "VkComponentMapping") {
VK_COMPONENT_SWIZZLE_G = 4,
VK_COMPONENT_SWIZZLE_B = 5,
VK_COMPONENT_SWIZZLE_A = 6,
-} VkComponentSwizzle;typedef enum VkImageAspectFlagBits {
+
+typedef enum VkImageAspectFlagBits {
VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
-} VkImageAspectFlagBits;codeSize / 4
codeSize / 4
typedef enum VkShaderStageFlagBits {
+
+typedef enum VkShaderStageFlagBits {
VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
@@ -2410,7 +2432,7 @@ val VkPipelineShaderStageCreateInfo = struct(VULKAN_PACKAGE, "VkPipelineShaderSt
VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
-} VkShaderStageFlagBits;typedef enum VkVertexInputRate {
+
+typedef enum VkVertexInputRate {
VK_VERTEX_INPUT_RATE_VERTEX = 0,
VK_VERTEX_INPUT_RATE_INSTANCE = 1,
-} VkVertexInputRate;zf may be represented using either a fixed-point or floating-point representation. However, a floating-point representation must be used if the depth/stencil attachment has a floating-point depth component. If an m-bit fixed-point representation is used, we assume that it represents each value k / (2m - 1)k {elem} { 0, 1, ..., 2m-1 }, as k (e.g. 1.0 is represented in binary as a string of all ones).
+ The framebuffer depth coordinate zf may be represented using either a fixed-point or floating-point representation. However, a floating-point representation must be used if the depth/stencil attachment has a floating-point depth component. If an m-bit fixed-point representation is used, we assume that it represents each value
+k / (2m - 1)
k {elem} { 0, 1, ..., 2m-1 }, as k (e.g. 1.0 is represented in binary as a string of all ones).
The viewport parameters shown in the above equations are found from these values as
@@ -2756,7 +2780,7 @@ val VkPipelineMultisampleStateCreateInfo = struct(VULKAN_PACKAGE, "VkPipelineMul
ceil(rasterizationSamples / 32)
ceil(rasterizationSamples / 32)
typedef enum VkPipelineCreateFlagBits {
+
+typedef enum VkPipelineCreateFlagBits {
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
-} VkPipelineCreateFlagBits;typedef enum VkSamplerAddressMode {
+
+typedef enum VkSamplerAddressMode {
VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
-} VkSamplerAddressMode;[0,1] for the respective u, v, or w coordinate as defined in the Wrapping Operation section.
@@ -3251,17 +3277,19 @@ val VkSamplerCreateInfo = struct(VULKAN_PACKAGE, "VkSamplerCreateInfo") {
nullable..const..opaque_p.member("pNext", "{@code NULL} or a pointer to an extension-specific structure.")
VkSamplerCreateFlags.member("flags", "reserved for future use.")
VkFilter.member("magFilter", """the magnification filter to apply to lookups, and is of type:
-typedef enum VkFilter {
+
+typedef enum VkFilter {
VK_FILTER_NEAREST = 0,
VK_FILTER_LINEAR = 1,
VK_FILTER_CUBIC_IMG = 1000015000,
-} VkFilter;typedef enum VkSamplerMipmapMode {
+
+typedef enum VkSamplerMipmapMode {
VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
-} VkSamplerMipmapMode;typedef enum VkBorderColor {
+
+typedef enum VkBorderColor {
VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
-} VkBorderColor;typedef enum VkDescriptorSetLayoutCreateFlagBits {
+
+typedef enum VkDescriptorSetLayoutCreateFlagBits {
VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
-} VkDescriptorSetLayoutCreateFlagBits;typedef enum VkDescriptorPoolCreateFlagBits {
+
+typedef enum VkDescriptorPoolCreateFlagBits {
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
-} VkDescriptorPoolCreateFlagBits;typedef enum VkAttachmentDescriptionFlagBits {
+
+typedef enum VkAttachmentDescriptionFlagBits {
VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
-} VkAttachmentDescriptionFlagBits;typedef enum VkAttachmentLoadOp {
+
+typedef enum VkAttachmentLoadOp {
VK_ATTACHMENT_LOAD_OP_LOAD = 0,
VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
-} VkAttachmentLoadOp;typedef enum VkAttachmentStoreOp {
+
+typedef enum VkAttachmentStoreOp {
VK_ATTACHMENT_STORE_OP_STORE = 0,
VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
-} VkAttachmentStoreOp;typedef enum VkSubpassDescriptionFlagBits {
+
+typedef enum VkSubpassDescriptionFlagBits {
VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
-} VkSubpassDescriptionFlagBits;typedef enum VkCommandPoolCreateFlagBits {
+
+typedef enum VkCommandPoolCreateFlagBits {
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
-} VkCommandPoolCreateFlagBits;typedef enum VkCommandBufferLevel {
+
+typedef enum VkCommandBufferLevel {
VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
-} VkCommandBufferLevel;typedef enum VkCommandBufferUsageFlagBits {
+
+typedef enum VkCommandBufferUsageFlagBits {
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
-} VkCommandBufferUsageFlagBits;void vkCmdDrawIndirectCountAMD(
+
+void vkCmdDrawIndirectCountAMD(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
- uint32_t stride);void vkCmdDrawIndexedIndirectCountAMD(
+
+void vkCmdDrawIndexedIndirectCountAMD(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
- uint32_t stride);VkResult vkAcquireXlibDisplayEXT(
+
+VkResult vkAcquireXlibDisplayEXT(
VkPhysicalDevice physicalDevice,
Display* dpy,
- VkDisplayKHR display);VkResult vkGetRandROutputDisplayEXT(
+
+VkResult vkGetRandROutputDisplayEXT(
VkPhysicalDevice physicalDevice,
Display* dpy,
RROutput rrOutput,
- VkDisplayKHR* pDisplay); extern VkDevice device;
+
+ extern VkDevice device;
extern VkImage image;
// Must call extension functions through a function pointer:
@@ -38,13 +39,14 @@ val EXT_debug_marker = "EXTDebugMarker".nativeClassVK("EXT_debug_marker", type =
// A subsequent error might print:
// Image 'Brick Diffuse Texture' (0xc0dec0dedeadbeef) is used in a
- // command buffer with no memory bound to it. extern VkDevice device;
+
+ extern VkDevice device;
extern VkCommandBuffer commandBuffer;
// Must call extension functions through a function pointer:
@@ -100,7 +102,7 @@ val EXT_debug_marker = "EXTDebugMarker".nativeClassVK("EXT_debug_marker", type =
vkCmdDrawIndexed(commandBuffer, 500, 1, 2000, 0, 0);
}
// End the house annotation started above
- pfnCmdDebugMarkerEndEXT(commandBuffer);VkResult vkDebugMarkerSetObjectTagEXT(
+
+VkResult vkDebugMarkerSetObjectTagEXT(
VkDevice device,
- VkDebugMarkerObjectTagInfoEXT* pTagInfo);VkResult vkDebugMarkerSetObjectNameEXT(
+
+VkResult vkDebugMarkerSetObjectNameEXT(
VkDevice device,
- VkDebugMarkerObjectNameInfoEXT* pNameInfo);void vkCmdDebugMarkerBeginEXT(
+
+void vkCmdDebugMarkerBeginEXT(
VkCommandBuffer commandBuffer,
- VkDebugMarkerMarkerInfoEXT* pMarkerInfo);void vkCmdDebugMarkerEndEXT(
- VkCommandBuffer commandBuffer);
+void vkCmdDebugMarkerEndEXT(
+ VkCommandBuffer commandBuffer);
void vkCmdDebugMarkerInsertEXT(
+
+void vkCmdDebugMarkerInsertEXT(
VkCommandBuffer commandBuffer,
- VkDebugMarkerMarkerInfoEXT* pMarkerInfo); VkResult res;
+
+ VkResult res;
VkDebugReportCallbackEXT cb1, cb2, cb3;
VkDebugReportCallbackCreateInfoEXT callback1 = {
@@ -58,7 +59,7 @@ val EXT_debug_report = "EXTDebugReport".nativeClassVK("EXT_debug_report", type =
// remove callbacks when cleaning up
vkDestroyDebugReportCallbackEXT(instance, cb1);
vkDestroyDebugReportCallbackEXT(instance, cb2);
- vkDestroyDebugReportCallbackEXT(instance, cb3);VkResult vkCreateDebugReportCallbackEXT(
+
+VkResult vkCreateDebugReportCallbackEXT(
VkInstance instance,
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDebugReportCallbackEXT* pCallback);void vkDestroyDebugReportCallbackEXT(
+
+void vkDestroyDebugReportCallbackEXT(
VkInstance instance,
VkDebugReportCallbackEXT callback,
- const VkAllocationCallbacks* pAllocator);void vkDebugReportMessageEXT(
+
+void vkDebugReportMessageEXT(
VkInstance instance,
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
@@ -333,7 +337,7 @@ val EXT_debug_report = "EXTDebugReport".nativeClassVK("EXT_debug_report", type =
size_t location,
int32_t messageCode,
const char* pLayerPrefix,
- const char* pMessage);VkResult vkReleaseDisplayEXT(
+
+VkResult vkReleaseDisplayEXT(
VkPhysicalDevice physicalDevice,
- VkDisplayKHR display);void vkCmdSetDiscardRectangleEXT(
+
+void vkCmdSetDiscardRectangleEXT(
VkCommandBuffer commandBuffer,
uint32_t firstDiscardRectangle,
uint32_t discardRectangleCount,
- const VkRect2D* pDiscardRectangles);i of {@code pDiscardRectangles} replace the current state for the discard rectangle index firstDiscardRectangle {plus} i, for i in [0, discardRectangleCount).
diff --git a/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/EXT_display_control.kt b/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/EXT_display_control.kt
index a0d6469752..9a27772396 100644
--- a/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/EXT_display_control.kt
+++ b/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/EXT_display_control.kt
@@ -147,10 +147,11 @@ val EXT_display_control = "EXTDisplayControl".nativeClassVK("EXT_display_control
VkResult vkDisplayPowerControlEXT(
+
+VkResult vkDisplayPowerControlEXT(
VkDevice device,
VkDisplayKHR display,
- const VkDisplayPowerInfoEXT* pDisplayPowerInfo);VkResult vkRegisterDeviceEventEXT(
+
+VkResult vkRegisterDeviceEventEXT(
VkDevice device,
const VkDeviceEventInfoEXT* pDeviceEventInfo,
const VkAllocationCallbacks* pAllocator,
- VkFence* pFence);VkResult vkRegisterDisplayEventEXT(
+
+VkResult vkRegisterDisplayEventEXT(
VkDevice device,
VkDisplayKHR display,
const VkDisplayEventInfoEXT* pDisplayEventInfo,
const VkAllocationCallbacks* pAllocator,
- VkFence* pFence);VkResult vkGetSwapchainCounterEXT(
+
+VkResult vkGetSwapchainCounterEXT(
VkDevice device,
VkSwapchainKHR swapchain,
VkSurfaceCounterFlagBitsEXT counter,
- uint64_t* pCounterValue);VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+
+VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
- VkSurfaceCapabilities2EXT* pSurfaceCapabilities);void vkSetHdrMetadataEXT(
+
+void vkSetHdrMetadataEXT(
VkDevice device,
uint32_t swapchainCount,
const VkSwapchainKHR* pSwapchains,
- const VkHdrMetadataEXT* pMetadata);if (condition) {
+
+if (condition) {
result = do_fast_path();
-} else {
+} else {
result = do_general_path();
-}if (allInvocationsARB(condition)) {
+
+if (allInvocationsARB(condition)) {
result = do_fast_path();
-} else {
+} else {
result = do_general_path();
-}VkResult vkGetRefreshCycleDurationGOOGLE(
+
+VkResult vkGetRefreshCycleDurationGOOGLE(
VkDevice device,
VkSwapchainKHR swapchain,
- VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);VkResult vkGetPastPresentationTimingGOOGLE(
+
+VkResult vkGetPastPresentationTimingGOOGLE(
VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pPresentationTimingCount,
- VkPastPresentationTimingGOOGLE* pPresentationTimings); VkSamplerCreateInfo createInfo =
+
+ VkSamplerCreateInfo createInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO // sType
// Other members set to application-desired values
@@ -29,7 +30,7 @@ val IMG_filter_cubic = "IMGFilterCubic".nativeClassVK("IMG_filter_cubic", type =
VkResult result = vkCreateSampler(
device,
&createInfo,
- &sampler); // TODO: Write some sample code here.
+ // TODO: Write some sample code here.
VkResult vkCreateDescriptorUpdateTemplateKHR(
+
+VkResult vkCreateDescriptorUpdateTemplateKHR(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);void vkDestroyDescriptorUpdateTemplateKHR(
+
+void vkDestroyDescriptorUpdateTemplateKHR(
VkDevice device,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator);void vkUpdateDescriptorSetWithTemplateKHR(
+
+void vkUpdateDescriptorSetWithTemplateKHR(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
- const void* pData);struct AppBufferView {
+
+struct AppBufferView {
VkBufferView bufferView;
uint32_t applicationRelatedInformation;
-};
+};
-struct AppDataStructure
-{
+struct AppDataStructure
+{
VkDescriptorImageInfo imageInfo; // a single image info
VkDescriptorBufferInfo bufferInfoArray[3]; // 3 buffer infos in an array
AppBufferView bufferView[2]; // An application defined structure containing a bufferView
// ... some more application related data
-};
+};
-const VkDescriptorUpdateTemplateEntryKHR descriptorUpdateTemplateEntries[] =
-{
+const VkDescriptorUpdateTemplateEntryKHR descriptorUpdateTemplateEntries[] =
+{
// binding to a single image descriptor
{
0, // binding
@@ -268,11 +273,11 @@ const VkDescriptorUpdateTemplateEntryKHR descriptorUpdateTemplateEntries[] =
offsetof(AppDataStructure, bufferView), // offset
sizeof(AppBufferView) // stride, bufferViews do not have to be compact
},
-};
+};
-// create an descriptor update template for descriptor set updates
-const VkDescriptorUpdateTemplateCreateInfoKHR createInfo =
-{
+// create an descriptor update template for descriptor set updates
+const VkDescriptorUpdateTemplateCreateInfoKHR createInfo =
+{
VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, // sType
NULL, // pNext
0, // flags
@@ -283,21 +288,21 @@ const VkDescriptorUpdateTemplateCreateInfoKHR createInfo =
0, // pipelineBindPoint, ignored by given templateType
0, // pipelineLayout, ignored by given templateType
0, // set, ignored by given templateType
-};
+};
-VkDescriptorUpdateTemplateKHR myDescriptorUpdateTemplate;
-myResult = vkCreatePipelineLayout(
+VkDescriptorUpdateTemplateKHR myDescriptorUpdateTemplate;
+myResult = vkCreatePipelineLayout(
myDevice,
&createInfo,
NULL,
&myDescriptorUpdateTemplate);
-}
+}
-AppDataStructure appData;
+AppDataStructure appData;
-// fill appData here or cache it in your engine
-vkUpdateDescriptorSetWithTemplateKHR(myDevice, myDescriptorSet, myDescriptorUpdateTemplate, &appData);void vkCmdPushDescriptorSetWithTemplateKHR(
+
+void vkCmdPushDescriptorSetWithTemplateKHR(
VkCommandBuffer commandBuffer,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
VkPipelineLayout layout,
uint32_t set,
- const void* pData);struct AppBufferView {
+
+struct AppBufferView {
VkBufferView bufferView;
uint32_t applicationRelatedInformation;
-};
+};
-struct AppDataStructure
-{
+struct AppDataStructure
+{
VkDescriptorImageInfo imageInfo; // a single image info
// ... some more application related data
-};
+};
-const VkDescriptorUpdateTemplateEntryKHR descriptorUpdateTemplateEntries[] =
-{
+const VkDescriptorUpdateTemplateEntryKHR descriptorUpdateTemplateEntries[] =
+{
// binding to a single image descriptor
{
0, // binding
@@ -372,11 +379,11 @@ const VkDescriptorUpdateTemplateEntryKHR descriptorUpdateTemplateEntries[] =
0 // stride is not required if descriptorCount is 1.
}
-};
+};
-// create an descriptor update template for descriptor set updates
-const VkDescriptorUpdateTemplateCreateInfoKHR createInfo =
-{
+// create an descriptor update template for descriptor set updates
+const VkDescriptorUpdateTemplateCreateInfoKHR createInfo =
+{
VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, // sType
NULL, // pNext
0, // flags
@@ -387,19 +394,19 @@ const VkDescriptorUpdateTemplateCreateInfoKHR createInfo =
VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
myPipelineLayout, // pipelineLayout
0, // set
-};
+};
-VkDescriptorUpdateTemplateKHR myDescriptorUpdateTemplate;
-myResult = vkCreatePipelineLayout(
+VkDescriptorUpdateTemplateKHR myDescriptorUpdateTemplate;
+myResult = vkCreatePipelineLayout(
myDevice,
&createInfo,
NULL,
&myDescriptorUpdateTemplate);
-}
+}
-AppDataStructure appData;
-// fill appData here or cache it in your engine
-vkCmdPushDescriptorSetWithTemplateKHR(myCmdBuffer, myDescriptorUpdateTemplate, myPipelineLayout, 0,&appData);VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+
+VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
- VkDisplayPropertiesKHR* pProperties);VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+
+VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
- VkDisplayPlanePropertiesKHR* pProperties);VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
+
+VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t* pDisplayCount,
- VkDisplayKHR* pDisplays);VkResult vkGetDisplayModePropertiesKHR(
+
+VkResult vkGetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
- VkDisplayModePropertiesKHR* pProperties);VkResult vkCreateDisplayModeKHR(
+
+VkResult vkCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDisplayModeKHR* pMode);VkResult vkGetDisplayPlaneCapabilitiesKHR(
+
+VkResult vkGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
uint32_t planeIndex,
- VkDisplayPlaneCapabilitiesKHR* pCapabilities);VkResult vkCreateDisplayPlaneSurfaceKHR(
+
+VkResult vkCreateDisplayPlaneSurfaceKHR(
VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface);VkResult vkCreateSharedSwapchainsKHR(
+
+VkResult vkCreateSharedSwapchainsKHR(
VkDevice device,
uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchains); // Get features with a hypothetical future extension.
+
+ // Get features with a hypothetical future extension.
VkHypotheticalExtensionFeaturesKHR hypotheticalFeatures =
{
VK_STRUCTURE_TYPE_HYPOTHETICAL_FEATURES_KHR, // sType
@@ -59,7 +60,7 @@ val KHR_get_physical_device_properties2 = "KHRGetPhysicalDeviceProperties2".nati
}
VkDevice device;
- vkCreateDevice(physicalDevice, &deviceCreateInfo, NULL, &device);void vkGetPhysicalDeviceFeatures2KHR(
+
+void vkGetPhysicalDeviceFeatures2KHR(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2KHR* pFeatures);void vkGetPhysicalDeviceProperties2KHR(
+
+void vkGetPhysicalDeviceProperties2KHR(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2KHR* pProperties);void vkGetPhysicalDeviceFormatProperties2KHR(
+
+void vkGetPhysicalDeviceFormatProperties2KHR(
VkPhysicalDevice physicalDevice,
VkFormat format,
- VkFormatProperties2KHR* pFormatProperties);VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
+
+VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
- VkImageFormatProperties2KHR* pImageFormatProperties);void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+
+void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
VkPhysicalDevice physicalDevice,
uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2KHR* pQueueFamilyProperties);void vkGetPhysicalDeviceMemoryProperties2KHR(
+
+void vkGetPhysicalDeviceMemoryProperties2KHR(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+
+void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
uint32_t* pPropertyCount,
- VkSparseImageFormatProperties2KHR* pProperties);VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+
+VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkSurfaceCapabilities2KHR* pSurfaceCapabilities);VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
+
+VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
uint32_t* pSurfaceFormatCount,
- VkSurfaceFormat2KHR* pSurfaceFormats);void vkTrimCommandPoolKHR(
+
+void vkTrimCommandPoolKHR(
VkDevice device,
VkCommandPool commandPool,
- VkCommandPoolTrimFlagsKHR flags);void vkCmdPushDescriptorSetKHR(
+
+void vkCmdPushDescriptorSetKHR(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t set,
uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites); VkSamplerCreateInfo createInfo =
+
+ VkSamplerCreateInfo createInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO // sType
// Other members set to application-desired values
@@ -32,7 +33,7 @@ val KHR_sampler_mirror_clamp_to_edge = "KHRSamplerMirrorClampToEdge".nativeClass
VkResult result = vkCreateSampler(
device,
&createInfo,
- &sampler);VkResult vkGetSwapchainStatusKHR(
+
+VkResult vkGetSwapchainStatusKHR(
VkDevice device,
- VkSwapchainKHR swapchain);E - corresponding electrical signal (value stored in memory)
E = 1.055 × L1/2.4 - 0.055 for 0.0031308 ≤ L ≤ 1
- 12.92 × L for 0 ≤ L < 0.0031308
+E = 1.055 × L1/2.4 - 0.055 for 0.0031308 ≤ L ≤ 1
+ 12.92 × L for 0 ≤ L < 0.0031308
E = (a × L + b)2.4 for 0.039 ≤ L ≤ 1
- b × L for 0 ≤ L < 0.039
+E = (a × L + b)2.4 for 0.039 ≤ L ≤ 1
+ b × L for 0 ≤ L < 0.039
a = 0.948b = 0.052c = 0.077
+a = 0.948
+b = 0.052
+c = 0.077
E = 1.055 × L1/2.4 - 0.055 for 0.0030186 ≤ L ≤ 1
- 12.92 × L for 0 ≤ L < 0.0030186
+E = 1.055 × L1/2.4 - 0.055 for 0.0030186 ≤ L ≤ 1
+ 12.92 × L for 0 ≤ L < 0.0030186
1.055 × L1/2.4 - 0.055 for 0.0031308 ≤ L ≤ 7.5913
-E = 12.92 × L for 0 ≤ L < 0.0031308
- -f(-L) for L < 0
+ 1.055 × L1/2.4 - 0.055 for 0.0031308 ≤ L ≤ 7.5913
+E = 12.92 × L for 0 ≤ L < 0.0031308
+ -f(-L) for L < 0
L - luminance of image is within [-0.6038, 7.5913].
E can be negative and/or > 1. That is how extended sRGB specifies colors outside the standard sRGB gamut. This means extended sRGB needs a floating point pixel format to cover the intended color range.
E = α × L^0.45 - (1 - α) for β ≤ L ≤ 1
- 4.5 × L for 0 ≤ L < β
+E = α × L^0.45 - (1 - α) for β ≤ L ≤ 1
+ 4.5 × L for 0 ≤ L < β
α = 1.099 and β = 0.018 for 10-bits and less per sample system (the values given in Rec.709)α = 1.0993 and β = 0.0181 for 12-bits per sample system
+α = 1.099 and β = 0.018 for 10-bits and less per sample system (the values given in Rec.709)
+α = 1.0993 and β = 0.0181 for 12-bits per sample system
E = ((c_1 + c_2 × L^m_1) / (1 + c_3 × L^m_1))^m_2
+E = ((c_1 + c_2 × L^m_1) / (1 + c_3 × L^m_1))^m_2
m1 = 2610 / 4096 × 1/4 = 0.1593017578125m2 = 2523 / 4096 × 128 = 78.84375c1 = 3424 / 4096 = 0.8359375 = c3 - c2 + 1c2 = 2413 / 4096 × 32 = 18.8515625c3 = 2392 / 4096 × 32 = 18.6875
+m1 = 2610 / 4096 × 1/4 = 0.1593017578125
+m2 = 2523 / 4096 × 128 = 78.84375
+c1 = 3424 / 4096 = 0.8359375 = c3 - c2 + 1
+c2 = 2413 / 4096 × 32 = 18.8515625
+c3 = 2392 / 4096 × 32 = 18.6875
E = r × sqrt(L) for 0 ≤ L ≤ 1
- a × ln(L - b) + c for 1 < L
+E = r × sqrt(L) for 0 ≤ L ≤ 1
+ a × ln(L - b) + c for 1 < L
L - is the signal normalized by the reference white levelr - is the reference white level and has a signal value of 0.5a = 0.17883277 and b = 0.28466892, and c = 0.55991073
+L - is the signal normalized by the reference white level
+r - is the reference white level and has a signal value of 0.5
+a = 0.17883277 and b = 0.28466892, and c = 0.55991073
E = L^1 / 2.19921875
+E = L^1 / 2.19921875
E = L^1 / 2.6
+E = L^1 / 2.6
void vkDestroySurfaceKHR(
+
+void vkDestroySurfaceKHR(
VkInstance instance,
VkSurfaceKHR surface,
- const VkAllocationCallbacks* pAllocator);VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+
+VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
- VkBool32* pSupported);VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+
+VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
- VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
+
+VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
- VkSurfaceFormatKHR* pSurfaceFormats);VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
+
+VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes);VkResult vkCreateSwapchainKHR(
+
+VkResult vkCreateSwapchainKHR(
VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchain);void vkDestroySwapchainKHR(
+
+void vkDestroySwapchainKHR(
VkDevice device,
VkSwapchainKHR swapchain,
- const VkAllocationCallbacks* pAllocator);VkResult vkGetSwapchainImagesKHR(
+
+VkResult vkGetSwapchainImagesKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
- VkImage* pSwapchainImages);VkResult vkAcquireNextImageKHR(
+
+VkResult vkAcquireNextImageKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint64_t timeout,
VkSemaphore semaphore,
VkFence fence,
- uint32_t* pImageIndex);VkResult vkQueuePresentKHR(
+
+VkResult vkQueuePresentKHR(
VkQueue queue,
- const VkPresentInfoKHR* pPresentInfo);VkResult vkCreateWin32SurfaceKHR(
+
+VkResult vkCreateWin32SurfaceKHR(
VkInstance instance,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface);VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
+
+VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex);VkResult vkCreateXlibSurfaceKHR(
+
+VkResult vkCreateXlibSurfaceKHR(
VkInstance instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface);VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
+
+VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
Display* dpy,
- VisualID visualID);void vkGetDeviceGroupPeerMemoryFeaturesKHX(
+
+void vkGetDeviceGroupPeerMemoryFeaturesKHX(
VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures);typedef enum VkPeerMemoryFeatureFlagBitsKHX {
+
+typedef enum VkPeerMemoryFeatureFlagBitsKHX {
VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001,
VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002,
VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004,
VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008,
-} VkPeerMemoryFeatureFlagBitsKHX;VkResult vkBindBufferMemory2KHX(
+
+VkResult vkBindBufferMemory2KHX(
VkDevice device,
uint32_t bindInfoCount,
- const VkBindBufferMemoryInfoKHX* pBindInfos);VkResult vkBindImageMemory2KHX(
+
+VkResult vkBindImageMemory2KHX(
VkDevice device,
uint32_t bindInfoCount,
- const VkBindImageMemoryInfoKHX* pBindInfos);void vkCmdSetDeviceMaskKHX(
+
+void vkCmdSetDeviceMaskKHX(
VkCommandBuffer commandBuffer,
- uint32_t deviceMask);VkResult vkGetDeviceGroupPresentCapabilitiesKHX(
+
+VkResult vkGetDeviceGroupPresentCapabilitiesKHX(
VkDevice device,
- VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities);VkResult vkGetDeviceGroupSurfacePresentModesKHX(
+
+VkResult vkGetDeviceGroupSurfacePresentModesKHX(
VkDevice device,
VkSurfaceKHR surface,
- VkDeviceGroupPresentModeFlagsKHX* pModes);VkResult vkAcquireNextImage2KHX(
+
+VkResult vkAcquireNextImage2KHX(
VkDevice device,
const VkAcquireNextImageInfoKHX* pAcquireInfo,
- uint32_t* pImageIndex);void vkCmdDispatchBaseKHX(
+
+void vkCmdDispatchBaseKHX(
VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
- uint32_t groupCountZ);groupCountX {times} groupCountY {times} groupCountZ local workgroups is assembled, with {@code WorkgroupId} values ranging from [baseGroup, baseGroup {plus} groupCount) in each component. #CmdDispatch() is equivalent to vkCmdDispatchBaseKHX(0,0,0,groupCountX,groupCountY,groupCountZ).
@@ -589,11 +598,12 @@ val KHX_device_group = "KHXDeviceGroup".nativeClassVK("KHX_device_group", type =
To query a set of rectangles used in presentation on the physical device, call:
- VkResult vkGetPhysicalDevicePresentRectanglesKHX(
+
+VkResult vkGetPhysicalDevicePresentRectanglesKHX(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pRectCount,
- VkRect2D* pRects); VkDeviceCreateInfo devCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+
+ VkDeviceCreateInfo devCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
// (not shown) fill out devCreateInfo as usual.
uint32_t deviceGroupCount = 0;
VkPhysicalDeviceGroupPropertiesKHX *props = NULL;
@@ -40,7 +41,7 @@ val KHX_device_group_creation = "KHXDeviceGroupCreation".nativeClassVK("KHX_devi
}
vkCreateDevice(props[0].physicalDevices[0], &devCreateInfo, NULL, &g_vkDevice);
- free(props);VkResult vkEnumeratePhysicalDeviceGroupsKHX(
+
+VkResult vkEnumeratePhysicalDeviceGroupsKHX(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties);void vkGetPhysicalDeviceExternalBufferPropertiesKHX(
+
+void vkGetPhysicalDeviceExternalBufferPropertiesKHX(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo,
- VkExternalBufferPropertiesKHX* pExternalBufferProperties);VkResult vkGetMemoryFdKHX(
+
+VkResult vkGetMemoryFdKHX(
VkDevice device,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagBitsKHX handleType,
- int* pFd);VkResult vkGetMemoryFdPropertiesKHX(
+
+VkResult vkGetMemoryFdPropertiesKHX(
VkDevice device,
VkExternalMemoryHandleTypeFlagBitsKHX handleType,
int fd,
- VkMemoryFdPropertiesKHX* pMemoryFdProperties);VkResult vkGetMemoryWin32HandleKHX(
+
+VkResult vkGetMemoryWin32HandleKHX(
VkDevice device,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagBitsKHX handleType,
- HANDLE* pHandle);VkResult vkGetMemoryWin32HandlePropertiesKHX(
+
+VkResult vkGetMemoryWin32HandlePropertiesKHX(
VkDevice device,
VkExternalMemoryHandleTypeFlagBitsKHX handleType,
HANDLE handle,
- VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties);void vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(
+
+void vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo,
- VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties);VkResult vkImportSemaphoreFdKHX(
+
+VkResult vkImportSemaphoreFdKHX(
VkDevice device,
- const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo);VkResult vkGetSemaphoreFdKHX(
+
+VkResult vkGetSemaphoreFdKHX(
VkDevice device,
VkSemaphore semaphore,
VkExternalSemaphoreHandleTypeFlagBitsKHX handleType,
- int* pFd);VkResult vkImportSemaphoreWin32HandleKHX(
+
+VkResult vkImportSemaphoreWin32HandleKHX(
VkDevice device,
- const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo);VkResult vkGetSemaphoreWin32HandleKHX(
+
+VkResult vkGetSemaphoreWin32HandleKHX(
VkDevice device,
VkSemaphore semaphore,
VkExternalSemaphoreHandleTypeFlagBitsKHX handleType,
- HANDLE* pHandle);VkResult vkCreateIOSSurfaceMVK(
+
+VkResult vkCreateIOSSurfaceMVK(
VkInstance instance,
const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface);VkResult vkCreateMacOSSurfaceMVK(
+
+VkResult vkCreateMacOSSurfaceMVK(
VkInstance instance,
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface); // setup secondary command buffer
+
+ // setup secondary command buffer
vkBeginCommandBuffer(generatedCmdBuffer, &beginInfo);
... setup its state as usual
@@ -104,7 +105,7 @@ val NVX_device_generated_commands = "NVXDeviceGeneratedCommands".nativeClassVK("
// memoryBarrierCount1,
// pMemoryBarriers&memoryBarrier,
...)
- vkCmdExecuteCommands(mainCmd, 1, &generatedCmdBuffer);void vkCmdProcessCommandsNVX(
+
+void vkCmdProcessCommandsNVX(
VkCommandBuffer commandBuffer,
- const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);void vkCmdReserveSpaceForCommandsNVX(
+
+void vkCmdReserveSpaceForCommandsNVX(
VkCommandBuffer commandBuffer,
- const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);VkResult vkCreateIndirectCommandsLayoutNVX(
+
+VkResult vkCreateIndirectCommandsLayoutNVX(
VkDevice device,
const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);void vkDestroyIndirectCommandsLayoutNVX(
+
+void vkDestroyIndirectCommandsLayoutNVX(
VkDevice device,
VkIndirectCommandsLayoutNVX indirectCommandsLayout,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateObjectTableNVX(
+
+VkResult vkCreateObjectTableNVX(
VkDevice device,
const VkObjectTableCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkObjectTableNVX* pObjectTable);void vkDestroyObjectTableNVX(
+
+void vkDestroyObjectTableNVX(
VkDevice device,
VkObjectTableNVX objectTable,
- const VkAllocationCallbacks* pAllocator);VkResult vkRegisterObjectsNVX(
+
+VkResult vkRegisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectTableEntryNVX* const* ppObjectTableEntries,
- const uint32_t* pObjectIndices);VkResult vkUnregisterObjectsNVX(
+
+VkResult vkUnregisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectEntryTypeNVX* pObjectEntryTypes,
- const uint32_t* pObjectIndices);void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+
+void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
VkPhysicalDevice physicalDevice,
VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
- VkDeviceGeneratedCommandsLimitsNVX* pLimits);\#version 450 core
+
+\#version 450 core
-\#extension GL_KHX_multiview : enable
-\#extension GL_NVX_multiview_per_view_attributes : enable
+\#extension GL_KHX_multiview : enable
+\#extension GL_NVX_multiview_per_view_attributes : enable
-layout(location = 0) in vec4 position;
-layout(set = 0, binding = 0) uniform Block { mat4 mvpPerView[2]; } buf;
+layout(location = 0) in vec4 position;
+layout(set = 0, binding = 0) uniform Block { mat4 mvpPerView[2]; } buf;
-void main()
-{
+void main()
+{
// Output both per-view positions and gl_Position as a function
// of gl_ViewIndex
gl_PositionPerViewNV[0] = buf.mvpPerView[0] * position;
gl_PositionPerViewNV[1] = buf.mvpPerView[1] * position;
gl_Position = buf.mvpPerView[gl_ViewIndex] * position;
-}VkViewport viewports[4];
-VkRect2D scissors[4];
-VkViewportWScalingNV scalings[4];
+
+VkViewport viewports[4];
+VkRect2D scissors[4];
+VkViewportWScalingNV scalings[4];
-for (int i = 0; i < 4; i++) {
+for (int i = 0; i < 4; i++) {
int x = (i & 2) ? 0 : currentWindowWidth / 2;
int y = (i & 1) ? 0 : currentWindowHeight / 2;
@@ -43,45 +44,46 @@ for (int i = 0; i < 4; i++) {
const float factor = 0.15;
scalings[i].xcoeff = ((i & 2) ? -1.0 : 1.0) * factor;
scalings[i].ycoeff = ((i & 1) ? -1.0 : 1.0) * factor;
-}
+}
-VkPipelineViewportWScalingStateCreateInfoNV vpWScalingStateInfo = { VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV };
+VkPipelineViewportWScalingStateCreateInfoNV vpWScalingStateInfo = { VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV };
-vpWScalingStateInfo.viewportWScalingEnable = VK_TRUE;
-vpWScalingStateInfo.viewportCount = 4;
-vpWScalingStateInfo.pViewportWScalings = &scalings[0];
+vpWScalingStateInfo.viewportWScalingEnable = VK_TRUE;
+vpWScalingStateInfo.viewportCount = 4;
+vpWScalingStateInfo.pViewportWScalings = &scalings[0];
-VkPipelineViewportStateCreateInfo vpStateInfo = { VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO };
-vpStateInfo.viewportCount = 4;
-vpStateInfo.pViewports = &viewports[0];
-vpStateInfo.scissorCount = 4;
-vpStateInfo.pScissors = &scissors[0];
-vpStateInfo.pNext = &vpWScalingStateInfo;// Vertex Shader
-// Draw a triangle that covers the whole screen
-const vec4 positions[3] = vec4[3](vec4(-1, -1, 0, 1),
+
+// Vertex Shader
+// Draw a triangle that covers the whole screen
+const vec4 positions[3] = vec4[3](vec4(-1, -1, 0, 1),
vec4( 3, -1, 0, 1),
vec4(-1, 3, 0, 1));
-out vec2 uv;
-void main()
-{
+out vec2 uv;
+void main()
+{
vec4 pos = positions[ gl_VertexID ];
gl_Position = pos;
uv = pos.xy;
-}
+}
-// Fragment Shader
-uniform sampler2D tex;
-uniform float xcoeff;
-uniform float ycoeff;
-out vec4 Color;
-in vec2 uv;
+// Fragment Shader
+uniform sampler2D tex;
+uniform float xcoeff;
+uniform float ycoeff;
+out vec4 Color;
+in vec2 uv;
-void main()
-{
+void main()
+{
// Handle uv as if upper right quadrant
vec2 uvabs = abs(uv);
@@ -96,7 +98,7 @@ void main()
P *= sign(uv);
Color = texture(tex, P * 0.5 + 0.5);
-}void vkCmdSetViewportWScalingNV(
+
+void vkCmdSetViewportWScalingNV(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
- const VkViewportWScalingNV* pViewportWScalings);i of {@code pViewportScalings} replace the current state for the viewport index firstViewport {plus} i, for i in [0, viewportCount).
diff --git a/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/NV_dedicated_allocation.kt b/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/NV_dedicated_allocation.kt
index ddc0dcdf26..21d6e68a97 100644
--- a/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/NV_dedicated_allocation.kt
+++ b/modules/templates/src/main/kotlin/org/lwjgl/vulkan/templates/NV_dedicated_allocation.kt
@@ -16,7 +16,8 @@ val NV_dedicated_allocation = "NVDedicatedAllocation".nativeClassVK("NV_dedicate
This extension adds a few small structures to resource creation and memory allocation: a new structure that flags whether am image/buffer will have a dedicated allocation, and a structure indicating the image or buffer that an allocation will be bound to.
// Create an image with
+
+ // Create an image with
// VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation
// set to VK_TRUE
@@ -79,7 +80,7 @@ val NV_dedicated_allocation = "NVDedicatedAllocation".nativeClassVK("NV_dedicate
device,
image,
memory,
- 0); // TODO: Write some sample code here.
+ // TODO: Write some sample code here.
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+
+VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -120,7 +121,7 @@ val NV_external_memory_capabilities = "NVExternalMemoryCapabilities".nativeClass
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
- VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); //
+
+ //
// Create an exportable memory object and export an external
// handle from it.
//
@@ -145,7 +146,7 @@ val NV_external_memory_win32 = "NVExternalMemoryWin32".nativeClassVK("NV_externa
}
// Get the external memory opaque FD handle
- vkGetMemoryWin32HandleNV(device, memory, &memoryHnd);VkResult vkGetMemoryWin32HandleNV(
+
+VkResult vkGetMemoryWin32HandleNV(
VkDevice device,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagsNV handleType,
- HANDLE* pHandle);layout(triangles) in;
-layout(triangle_strip) out;
-layout(max_vertices=3) out;
+
+layout(triangles) in;
+layout(triangle_strip) out;
+layout(max_vertices=3) out;
-in Inputs {
+in Inputs {
vec2 texcoord;
vec4 baseColor;
-} v_in[];
-out Outputs {
+} v_in[];
+out Outputs {
vec2 texcoord;
vec4 baseColor;
-};
+};
-void main()
-{
+void main()
+{
int layer = compute_layer();
for (int i = 0; i < 3; i++) {
gl_Position = gl_in[i].gl_Position;
@@ -49,36 +50,37 @@ void main()
gl_Layer = layer;
EmitVertex();
}
-}\#extension GL_NV_geometry_shader_passthrough : require
+
+\#extension GL_NV_geometry_shader_passthrough : require
-layout(triangles) in;
-// No output primitive layout qualifiers required.
+layout(triangles) in;
+// No output primitive layout qualifiers required.
-// Redeclare gl_PerVertex to pass through "gl_Position".
-layout(passthrough) in gl_PerVertex {
+// Redeclare gl_PerVertex to pass through "gl_Position".
+layout(passthrough) in gl_PerVertex {
vec4 gl_Position;
-} gl_in[];
+} gl_in[];
-// Declare "Inputs" with "passthrough" to automatically copy members.
-layout(passthrough) in Inputs {
+// Declare "Inputs" with "passthrough" to automatically copy members.
+layout(passthrough) in Inputs {
vec2 texcoord;
vec4 baseColor;
-} v_in[];
+} v_in[];
-// No output block declaration required.
+// No output block declaration required.
-void main()
-{
+void main()
+{
// The shader simply computes and writes gl_Layer. We don't
// loop over three vertices or call EmitVertex().
gl_Layer = compute_layer();
-} char const vss[] =
+
+ char const vss[] =
"\#version 450 core\n"
"layout(location = 0) in vec2 aVertex;\n"
"layout(location = 1) in vec4 aColor;\n"
@@ -33,7 +34,7 @@ val NV_glsl_shader = "NVGLSLShader".nativeClassVK("NV_glsl_shader", type = "devi
vertexShaderInfo.codeSize = sizeof vss;
vertexShaderInfo.pCode = vss;
VkShaderModule vertexShader;
- vkCreateShaderModule(device, &vertexShaderInfo, 0, &vertexShader); //
+
+ //
// Import a memory object from Direct3D 11, and synchronize
// access to it in Vulkan using keyed mutex objects.
//
@@ -141,7 +142,7 @@ val NV_win32_keyed_mutex = "NVWin32KeyedMutex".nativeClassVK("NV_win32_keyed_mut
VkSubmitInfo submit_info = { VK_STRUCTURE_TYPE_SUBMIT_INFO, &keyedMutex };
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &cmd_buf;
- vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);VkResult vkCreateInstance(
+
+VkResult vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkInstance* pInstance);void vkDestroyInstance(
+
+void vkDestroyInstance(
VkInstance instance,
- const VkAllocationCallbacks* pAllocator);VkResult vkEnumeratePhysicalDevices(
+
+VkResult vkEnumeratePhysicalDevices(
VkInstance instance,
uint32_t* pPhysicalDeviceCount,
- VkPhysicalDevice* pPhysicalDevices);void vkGetPhysicalDeviceFeatures(
+
+void vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures);void vkGetPhysicalDeviceFormatProperties(
+
+void vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
- VkFormatProperties* pFormatProperties);VkResult vkGetPhysicalDeviceImageFormatProperties(
+
+VkResult vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
- VkImageFormatProperties* pImageFormatProperties);void vkGetPhysicalDeviceProperties(
+
+void vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties);void vkGetPhysicalDeviceQueueFamilyProperties(
+
+void vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties* pQueueFamilyProperties);void vkGetPhysicalDeviceMemoryProperties(
+
+void vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties* pMemoryProperties);PFN_vkVoidFunction vkGetInstanceProcAddr(
+
+PFN_vkVoidFunction vkGetInstanceProcAddr(
VkInstance instance,
- const char* pName);PFN_vkVoidFunction vkGetDeviceProcAddr(
+
+PFN_vkVoidFunction vkGetDeviceProcAddr(
VkDevice device,
- const char* pName);VkResult vkCreateDevice(
+
+VkResult vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDevice* pDevice);void vkDestroyDevice(
+
+void vkDestroyDevice(
VkDevice device,
- const VkAllocationCallbacks* pAllocator);VkResult vkEnumerateInstanceExtensionProperties(
+
+VkResult vkEnumerateInstanceExtensionProperties(
const char* pLayerName,
uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties);VkResult vkEnumerateDeviceExtensionProperties(
+
+VkResult vkEnumerateDeviceExtensionProperties(
VkPhysicalDevice physicalDevice,
const char* pLayerName,
uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties);VkResult vkEnumerateInstanceLayerProperties(
+
+VkResult vkEnumerateInstanceLayerProperties(
uint32_t* pPropertyCount,
- VkLayerProperties* pProperties);VkResult vkEnumerateDeviceLayerProperties(
+
+VkResult vkEnumerateDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
- VkLayerProperties* pProperties);void vkGetDeviceQueue(
+
+void vkGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
- VkQueue* pQueue);VkResult vkQueueSubmit(
+
+VkResult vkQueueSubmit(
VkQueue queue,
uint32_t submitCount,
const VkSubmitInfo* pSubmits,
- VkFence fence);VkResult vkQueueWaitIdle(
- VkQueue queue);
+VkResult vkQueueWaitIdle(
+ VkQueue queue);
VkResult vkDeviceWaitIdle(
- VkDevice device);
+VkResult vkDeviceWaitIdle(
+ VkDevice device);
VkResult vkAllocateMemory(
+
+VkResult vkAllocateMemory(
VkDevice device,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDeviceMemory* pMemory);void vkFreeMemory(
+
+void vkFreeMemory(
VkDevice device,
VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator);VkResult vkMapMemory(
+
+VkResult vkMapMemory(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
- void** ppData);void vkUnmapMemory(
+
+void vkUnmapMemory(
VkDevice device,
- VkDeviceMemory memory);VkResult vkFlushMappedMemoryRanges(
+
+VkResult vkFlushMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges);VkResult vkInvalidateMappedMemoryRanges(
+
+VkResult vkInvalidateMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges);void vkGetDeviceMemoryCommitment(
+
+void vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes);VkResult vkBindBufferMemory(
+
+VkResult vkBindBufferMemory(
VkDevice device,
VkBuffer buffer,
VkDeviceMemory memory,
- VkDeviceSize memoryOffset);VkResult vkBindImageMemory(
+
+VkResult vkBindImageMemory(
VkDevice device,
VkImage image,
VkDeviceMemory memory,
- VkDeviceSize memoryOffset);void vkGetBufferMemoryRequirements(
+
+void vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements);void vkGetImageMemoryRequirements(
+
+void vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
- VkMemoryRequirements* pMemoryRequirements);void vkGetImageSparseMemoryRequirements(
+
+void vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements* pSparseMemoryRequirements);void vkGetPhysicalDeviceSparseImageFormatProperties(
+
+void vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -4185,7 +4219,7 @@ val VK10 = "VK10".nativeClass(VULKAN_PACKAGE, "VK10", prefix = "VK", binding = V
VkImageUsageFlags usage,
VkImageTiling tiling,
uint32_t* pPropertyCount,
- VkSparseImageFormatProperties* pProperties);VkResult vkQueueBindSparse(
+
+VkResult vkQueueBindSparse(
VkQueue queue,
uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo,
- VkFence fence);VkResult vkCreateFence(
+
+VkResult vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkFence* pFence);void vkDestroyFence(
+
+void vkDestroyFence(
VkDevice device,
VkFence fence,
- const VkAllocationCallbacks* pAllocator);VkResult vkResetFences(
+
+VkResult vkResetFences(
VkDevice device,
uint32_t fenceCount,
- const VkFence* pFences);VkResult vkGetFenceStatus(
+
+VkResult vkGetFenceStatus(
VkDevice device,
- VkFence fence);VkResult vkWaitForFences(
+
+VkResult vkWaitForFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences,
VkBool32 waitAll,
- uint64_t timeout);VkResult vkCreateSemaphore(
+
+VkResult vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSemaphore* pSemaphore);void vkDestroySemaphore(
+
+void vkDestroySemaphore(
VkDevice device,
VkSemaphore semaphore,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateEvent(
+
+VkResult vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkEvent* pEvent);void vkDestroyEvent(
+
+void vkDestroyEvent(
VkDevice device,
VkEvent event,
- const VkAllocationCallbacks* pAllocator);VkResult vkGetEventStatus(
+
+VkResult vkGetEventStatus(
VkDevice device,
- VkEvent event);VkResult vkSetEvent(
+
+VkResult vkSetEvent(
VkDevice device,
- VkEvent event);VkResult vkResetEvent(
+
+VkResult vkResetEvent(
VkDevice device,
- VkEvent event);VkResult vkCreateQueryPool(
+
+VkResult vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkQueryPool* pQueryPool);void vkDestroyQueryPool(
+
+void vkDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool,
- const VkAllocationCallbacks* pAllocator);VkResult vkGetQueryPoolResults(
+
+VkResult vkGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
@@ -5023,7 +5073,7 @@ val VK10 = "VK10".nativeClass(VULKAN_PACKAGE, "VK10", prefix = "VK", binding = V
size_t dataSize,
void* pData,
VkDeviceSize stride,
- VkQueryResultFlags flags);typedef enum VkQueryResultFlagBits {
+
+typedef enum VkQueryResultFlagBits {
VK_QUERY_RESULT_64_BIT = 0x00000001,
VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
-} VkQueryResultFlagBits;VkResult vkCreateBuffer(
+
+VkResult vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer);void vkDestroyBuffer(
+
+void vkDestroyBuffer(
VkDevice device,
VkBuffer buffer,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateBufferView(
+
+VkResult vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkBufferView* pView);void vkDestroyBufferView(
+
+void vkDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateImage(
+
+VkResult vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkImage* pImage);void vkDestroyImage(
+
+void vkDestroyImage(
VkDevice device,
VkImage image,
- const VkAllocationCallbacks* pAllocator);void vkGetImageSubresourceLayout(
+
+void vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
- VkSubresourceLayout* pLayout);VkResult vkCreateImageView(
+
+VkResult vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkImageView* pView);void vkDestroyImageView(
+
+void vkDestroyImageView(
VkDevice device,
VkImageView imageView,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateShaderModule(
+
+VkResult vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkShaderModule* pShaderModule);void vkDestroyShaderModule(
+
+void vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreatePipelineCache(
+
+VkResult vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkPipelineCache* pPipelineCache);void vkDestroyPipelineCache(
+
+void vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
- const VkAllocationCallbacks* pAllocator);VkResult vkGetPipelineCacheData(
+
+VkResult vkGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
size_t* pDataSize,
- void* pData);typedef enum VkPipelineCacheHeaderVersion {
+
+typedef enum VkPipelineCacheHeaderVersion {
VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
-} VkPipelineCacheHeaderVersion;VkResult vkMergePipelineCaches(
+
+VkResult vkMergePipelineCaches(
VkDevice device,
VkPipelineCache dstCache,
uint32_t srcCacheCount,
- const VkPipelineCache* pSrcCaches);VkResult vkCreateGraphicsPipelines(
+
+VkResult vkCreateGraphicsPipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines);VkResult vkCreateComputePipelines(
+
+VkResult vkCreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines);void vkDestroyPipeline(
+
+void vkDestroyPipeline(
VkDevice device,
VkPipeline pipeline,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreatePipelineLayout(
+
+VkResult vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkPipelineLayout* pPipelineLayout);void vkDestroyPipelineLayout(
+
+void vkDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateSampler(
+
+VkResult vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkSampler* pSampler);void vkDestroySampler(
+
+void vkDestroySampler(
VkDevice device,
VkSampler sampler,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateDescriptorSetLayout(
+
+VkResult vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorSetLayout* pSetLayout);void vkDestroyDescriptorSetLayout(
+
+void vkDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateDescriptorPool(
+
+VkResult vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorPool* pDescriptorPool);void vkDestroyDescriptorPool(
+
+void vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
- const VkAllocationCallbacks* pAllocator);VkResult vkResetDescriptorPool(
+
+VkResult vkResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
- VkDescriptorPoolResetFlags flags);VkResult vkAllocateDescriptorSets(
+
+VkResult vkAllocateDescriptorSets(
VkDevice device,
const VkDescriptorSetAllocateInfo* pAllocateInfo,
- VkDescriptorSet* pDescriptorSets);VkResult vkFreeDescriptorSets(
+
+VkResult vkFreeDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets);void vkUpdateDescriptorSets(
+
+void vkUpdateDescriptorSets(
VkDevice device,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
- const VkCopyDescriptorSet* pDescriptorCopies);VkResult vkCreateFramebuffer(
+
+VkResult vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkFramebuffer* pFramebuffer);void vkDestroyFramebuffer(
+
+void vkDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
- const VkAllocationCallbacks* pAllocator);VkResult vkCreateRenderPass(
+
+VkResult vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass);void vkDestroyRenderPass(
+
+void vkDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
- const VkAllocationCallbacks* pAllocator);void vkGetRenderAreaGranularity(
+
+void vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
- VkExtent2D* pGranularity);VkResult vkCreateCommandPool(
+
+VkResult vkCreateCommandPool(
VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkCommandPool* pCommandPool);void vkDestroyCommandPool(
+
+void vkDestroyCommandPool(
VkDevice device,
VkCommandPool commandPool,
- const VkAllocationCallbacks* pAllocator);VkResult vkResetCommandPool(
+
+VkResult vkResetCommandPool(
VkDevice device,
VkCommandPool commandPool,
- VkCommandPoolResetFlags flags);typedef enum VkCommandPoolResetFlagBits {
+
+typedef enum VkCommandPoolResetFlagBits {
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-} VkCommandPoolResetFlagBits;VkResult vkAllocateCommandBuffers(
+
+VkResult vkAllocateCommandBuffers(
VkDevice device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
- VkCommandBuffer* pCommandBuffers);void vkFreeCommandBuffers(
+
+void vkFreeCommandBuffers(
VkDevice device,
VkCommandPool commandPool,
uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers);VkResult vkBeginCommandBuffer(
+
+VkResult vkBeginCommandBuffer(
VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo);VkResult vkEndCommandBuffer(
- VkCommandBuffer commandBuffer);
+VkResult vkEndCommandBuffer(
+ VkCommandBuffer commandBuffer);
VkResult vkResetCommandBuffer(
+
+VkResult vkResetCommandBuffer(
VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags);typedef enum VkCommandBufferResetFlagBits {
+
+typedef enum VkCommandBufferResetFlagBits {
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-} VkCommandBufferResetFlagBits;void vkCmdBindPipeline(
+
+void vkCmdBindPipeline(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline);typedef enum VkPipelineBindPoint {
+
+typedef enum VkPipelineBindPoint {
VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
VK_PIPELINE_BIND_POINT_COMPUTE = 1,
-} VkPipelineBindPoint;void vkCmdSetViewport(
+
+void vkCmdSetViewport(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
- const VkViewport* pViewports);i of {@code pViewports} replace the current state for the viewport index firstViewport {plus} i, for i in [0, viewportCount).
@@ -7399,11 +7499,12 @@ val VK10 = "VK10".nativeClass(VULKAN_PACKAGE, "VK10", prefix = "VK", binding = V
(xf,yf) lie within the scissor rectangle corresponding to the viewport index (see Controlling the Viewport) used by the primitive that generated the fragment. If the pipeline state object is created without #DYNAMIC_STATE_SCISSOR enabled then the scissor rectangles are set by the ##VkPipelineViewportStateCreateInfo state of the pipeline state object. Otherwise, to dynamically set the scissor rectangles call:
- void vkCmdSetScissor(
+
+void vkCmdSetScissor(
VkCommandBuffer commandBuffer,
uint32_t firstScissor,
uint32_t scissorCount,
- const VkRect2D* pScissors);i of {@code pScissors} replace the current state for the scissor index firstScissor + i, for i in [0, scissorCount).
@@ -7461,9 +7562,10 @@ val VK10 = "VK10".nativeClass(VULKAN_PACKAGE, "VK10", prefix = "VK", binding = V
void vkCmdSetLineWidth(
+
+void vkCmdSetLineWidth(
VkCommandBuffer commandBuffer,
- float lineWidth);void vkCmdSetDepthBias(
+
+void vkCmdSetDepthBias(
VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
- float depthBiasSlopeFactor);m of a triangle is
- m = sqrt((∂zf / ∂xf)2 + (∂zf / ∂yf)2)
+ m = sqrt((∂zf / ∂xf)2 + (∂zf / ∂yf)2)
(xf, yf, zf) is a point on the triangle. m may be approximated as
- m = max(abs(∂zf / ∂xf), abs(∂zf / ∂yf))
+ m = max(abs(∂zf / ∂xf), abs(∂zf / ∂yf))
r is an implementation-dependent parameter that depends on the depth buffer representation. It is the smallest difference in framebuffer coordinate z values that is guaranteed to remain distinct throughout polygon rasterization and in the depth buffer. All pairs of fragments generated by the rasterization of two polygons with otherwise identical vertices, but zf values that differ by r, will have distinct depth values.
@@ -7534,9 +7639,10 @@ val VK10 = "VK10".nativeClass(VULKAN_PACKAGE, "VK10", prefix = "VK", binding = V
The bias value o for a polygon is
- m × depthBiasSlopeFactor + r × depthBiasConstantFactor depthBiasClamp = 0 or NaN
-o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, depthBiasClamp) depthBiasClamp > 0
- max(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, depthBiasClamp) depthBiasClamp < 0
+ m × depthBiasSlopeFactor + r × depthBiasConstantFactor depthBiasClamp = 0 or NaN
+o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, depthBiasClamp) depthBiasClamp > 0
+ max(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, depthBiasClamp) depthBiasClamp < 0
m is computed as described above. If the depth buffer uses a fixed-point representation, m is a function of depth values in the range [0,1], and o is applied to depth values in the same range.
@@ -7582,9 +7688,10 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
void vkCmdSetBlendConstants(
+
+void vkCmdSetBlendConstants(
VkCommandBuffer commandBuffer,
- const float blendConstants[4]);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 {@code depthBoundsTestEnable} member of ##VkPipelineDepthStencilStateCreateInfo: If the pipeline state object is created without the #DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled then the range of values used in the depth bounds test are defined by the {@code minDepthBounds} and {@code maxDepthBounds} members of the ##VkPipelineDepthStencilStateCreateInfo structure. Otherwise, to dynamically set the depth bounds range values call:
- void vkCmdSetDepthBounds(
+
+void vkCmdSetDepthBounds(
VkCommandBuffer commandBuffer,
float minDepthBounds,
- float maxDepthBounds);void vkCmdSetStencilCompareMask(
+
+void vkCmdSetStencilCompareMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- uint32_t compareMask);typedef enum VkStencilFaceFlagBits {
+
+typedef enum VkStencilFaceFlagBits {
VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
VK_STENCIL_FACE_BACK_BIT = 0x00000002,
VK_STENCIL_FRONT_AND_BACK = 0x00000003,
-} VkStencilFaceFlagBits;void vkCmdSetStencilWriteMask(
+
+void vkCmdSetStencilWriteMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- uint32_t writeMask);void vkCmdSetStencilReference(
+
+void vkCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- uint32_t reference);void vkCmdBindDescriptorSets(
+
+void vkCmdBindDescriptorSets(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
@@ -7822,7 +7935,7 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount,
- const uint32_t* pDynamicOffsets);void vkCmdBindIndexBuffer(
+
+void vkCmdBindIndexBuffer(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
- VkIndexType indexType);typedef enum VkIndexType {
+
+typedef enum VkIndexType {
VK_INDEX_TYPE_UINT16 = 0,
VK_INDEX_TYPE_UINT32 = 1,
-} VkIndexType;void vkCmdBindVertexBuffers(
+
+void vkCmdBindVertexBuffers(
VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets);i of {@code pBuffers} and {@code pOffsets} replace the current state for the vertex input binding firstBinding + i, for i in [0, bindingCount). The vertex input binding is updated to start at the offset indicated by {@code pOffsets}[i] from the start of the buffer {@code pBuffers}[i]. All vertex input attributes that use each of these bindings will use these updated addresses in their address calculations for subsequent draw commands.
@@ -8005,12 +8121,13 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
void vkCmdDraw(
+
+void vkCmdDraw(
VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
- uint32_t firstInstance);void vkCmdDrawIndexed(
+
+void vkCmdDrawIndexed(
VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
int32_t vertexOffset,
- uint32_t firstInstance);void vkCmdDrawIndirect(
+
+void vkCmdDrawIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
- uint32_t stride);void vkCmdDrawIndexedIndirect(
+
+void vkCmdDrawIndexedIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
- uint32_t stride);void vkCmdDispatch(
+
+void vkCmdDispatch(
VkCommandBuffer commandBuffer,
uint32_t groupCountX,
uint32_t groupCountY,
- uint32_t groupCountZ);groupCountX {times} groupCountY {times} groupCountZ local workgroups is assembled.
@@ -8369,10 +8490,11 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
void vkCmdDispatchIndirect(
+
+void vkCmdDispatchIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
- VkDeviceSize offset);void vkCmdCopyBuffer(
+
+void vkCmdCopyBuffer(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
uint32_t regionCount,
- const VkBufferCopy* pRegions);void vkCmdCopyImage(
+
+void vkCmdCopyImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
- const VkImageCopy* pRegions);void vkCmdBlitImage(
+
+void vkCmdBlitImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
@@ -8614,7 +8739,7 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit* pRegions,
- VkFilter filter);void vkCmdCopyBufferToImage(
+
+void vkCmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
- const VkBufferImageCopy* pRegions);void vkCmdCopyImageToBuffer(
+
+void vkCmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
- const VkBufferImageCopy* pRegions);void vkCmdUpdateBuffer(
+
+void vkCmdUpdateBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
- const void* pData);void vkCmdFillBuffer(
+
+void vkCmdFillBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize size,
- uint32_t data);void vkCmdClearColorImage(
+
+void vkCmdClearColorImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges);void vkCmdClearDepthStencilImage(
+
+void vkCmdClearDepthStencilImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges);void vkCmdClearAttachments(
+
+void vkCmdClearAttachments(
VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
- const VkClearRect* pRects);void vkCmdResolveImage(
+
+void vkCmdResolveImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
- const VkImageResolve* pRegions);void vkCmdSetEvent(
+
+void vkCmdSetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
- VkPipelineStageFlags stageMask);void vkCmdResetEvent(
+
+void vkCmdResetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
- VkPipelineStageFlags stageMask);void vkCmdWaitEvents(
+
+void vkCmdWaitEvents(
VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
@@ -9450,7 +9586,7 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier* pImageMemoryBarriers);void vkCmdPipelineBarrier(
+
+void vkCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
@@ -9549,7 +9686,7 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier* pImageMemoryBarriers);typedef enum VkDependencyFlagBits {
+
+typedef enum VkDependencyFlagBits {
VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
-} VkDependencyFlagBits;void vkCmdBeginQuery(
+
+void vkCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
- VkQueryControlFlags flags);typedef enum VkQueryControlFlagBits {
+
+typedef enum VkQueryControlFlagBits {
VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
-} VkQueryControlFlagBits;void vkCmdEndQuery(
+
+void vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- uint32_t query);void vkCmdResetQueryPool(
+
+void vkCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
- uint32_t queryCount);[firstQuery, firstQuery + queryCount - 1] to unavailable.
@@ -9822,11 +9964,12 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
void vkCmdWriteTimestamp(
+
+void vkCmdWriteTimestamp(
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
- uint32_t query);void vkCmdCopyQueryPoolResults(
+
+void vkCmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
@@ -9901,7 +10045,7 @@ o = min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, dept
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize stride,
- VkQueryResultFlags flags);void vkCmdPushConstants(
+
+void vkCmdPushConstants(
VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
uint32_t size,
- const void* pValues);void vkCmdBeginRenderPass(
+
+void vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
- VkSubpassContents contents);typedef enum VkSubpassContents {
+
+typedef enum VkSubpassContents {
VK_SUBPASS_CONTENTS_INLINE = 0,
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
-} VkSubpassContents;void vkCmdNextSubpass(
+
+void vkCmdNextSubpass(
VkCommandBuffer commandBuffer,
- VkSubpassContents contents);void vkCmdEndRenderPass(
- VkCommandBuffer commandBuffer);
+void vkCmdEndRenderPass(
+ VkCommandBuffer commandBuffer);
void vkCmdExecuteCommands(
+
+void vkCmdExecuteCommands(
VkCommandBuffer commandBuffer,
uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers);