Change log for August 12, 2016 Vulkan 1.0.24 spec update:

* Bump API patch number and header version number to 24 for this update.

Github Issues:

  * Fix type mismatch in swapchain image equivalency table (public issue
    289).
  * Fix a copy-and-paste error in the description of
    flink:vkGetSwapchainImagesKHR::pname:pSwapchainImages, that said it
    was an array of ``sname:VkSwapchainImageKHR structures'' instead of
    an array of ``sname:VkImage handles'' (public issue 292).
  * Specify that ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT is only valid
    for ename:VK_IMAGE_TYPE_2D images (public issue 293).
  * Add a valid usage statement to flink:vkCmdExecuteCommands saying
    that when called outside a render pass instance, the secondary
    command buffers must not have been created with the
    ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT (public issue
    297).
  * Fix description of +VK_NO_STDINT_H+ in the
    <<boilerplate-platform-macros,platform macros>> section (public
    issue 314).

Internal Issues:

  * Normalize the language for the remaining built-in variables in the
    <<interfaces-builtin-variables,Built-In Variables>> section. Fix
    code:FrontFacing and code:HelperInvocation, as they should be of
    code:boolean type rather than code:integer (internal issue 323).
  * Clarify that when ename:VK_WHOLE_SIZE is used for a buffer
    descriptor range, the effective range must still be within the max
    buffer range (internal issue 426).
  * Clarify that command buffers and descriptor sets are allocated
    rather than created. Also clarify when the recording state of a
    command buffer is relevant (internal issue 434).

ChangeLog.txt

@@ -1139,3 +1139,40 @@ Other Commits:
     sname:VkPipelineInputAssemblyStateCreateInfo are described to match
     their order in the structures.
 
+-----------------------------------------------------
+
+Change log for August 12, 2016 Vulkan 1.0.24 spec update:
+
+  * Bump API patch number and header version number to 24 for this update.
+
+Github Issues:
+
+  * Fix type mismatch in swapchain image equivalency table (public issue
+    289).
+  * Fix a copy-and-paste error in the description of
+    flink:vkGetSwapchainImagesKHR::pname:pSwapchainImages, that said it
+    was an array of ``sname:VkSwapchainImageKHR structures'' instead of
+    an array of ``sname:VkImage handles'' (public issue 292).
+  * Specify that ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT is only valid
+    for ename:VK_IMAGE_TYPE_2D images (public issue 293).
+  * Add a valid usage statement to flink:vkCmdExecuteCommands saying
+    that when called outside a render pass instance, the secondary
+    command buffers must not have been created with the
+    ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT (public issue
+    297).
+  * Fix description of +VK_NO_STDINT_H+ in the
+    <<boilerplate-platform-macros,platform macros>> section (public
+    issue 314).
+
+Internal Issues:
+
+  * Normalize the language for the remaining built-in variables in the
+    <<interfaces-builtin-variables,Built-In Variables>> section. Fix
+    code:FrontFacing and code:HelperInvocation, as they should be of
+    code:boolean type rather than code:integer (internal issue 323).
+  * Clarify that when ename:VK_WHOLE_SIZE is used for a buffer
+    descriptor range, the effective range must still be within the max
+    buffer range (internal issue 426).
+  * Clarify that command buffers and descriptor sets are allocated
+    rather than created. Also clarify when the recording state of a
+    command buffer is relevant (internal issue 434).

doc/specs/vulkan/Makefile

@@ -134,7 +134,7 @@ GENDEPENDS = api/timeMarker validity/timeMarker hostsynctable/timeMarker
 COMMONDOCS = $(CHAPTERS) $(GENINCLUDE) $(GENDEPENDS)
 # A generated included file with the spec version, date, and git commit
 SPECVERSION = specversion.txt
-SPECREVISION = 1.0.23
+SPECREVISION = 1.0.24
 SPECREMARK =
 
 # Spec targets

doc/specs/vulkan/api/defines/VK_HEADER_VERSION.txt

@@ -8,6 +8,6 @@ ifdef::doctype-manpage[]
 endif::doctype-manpage[]
 ------------------------------------------------------------------------------
 // Version of this file
-#define VK_HEADER_VERSION 23
+#define VK_HEADER_VERSION 24
 
 ------------------------------------------------------------------------------

doc/specs/vulkan/appendices/boilerplate.txt

@@ -272,11 +272,12 @@ dname:VKAPI_ATTR or dname:VKAPI_CALL, depending on the compiler.
 
 // @refBegin VK_NO_STDINT_H - control definition of +<stdint.h>+ types
 
-If the +VK_NO_STDINT_H+ macro is defined at compile time, it indicates that
+If the +VK_NO_STDINT_H+ macro is defined by the application at compile time,
-the system +<stdint.h>+ does not define some required integer types, and
+extended integer types required by +vulkan.h+, such as +uint8_t+, must: also
-+vk_platform.h+ will declare fallback definitions of those types. This is
+be defined by the application. Otherwise, +vulkan.h+ will not compile. If
-included for backwards compatibility with very old compilers, such as
++VK_NO_STDINT_H+ is not defined, the system +<stdint.h>+ is used to define
-Microsoft Visual Studio version 2008 or before.
+these types, or there is a fallback path when Microsoft Visual Studio
+version 2008 and earlier versions are detected at compile time.
 
 // @refEnd VK_NO_STDINT_H
 

doc/specs/vulkan/appendices/glossary.txt

@@ -394,7 +394,7 @@ Image View::
 
 Immutable Sampler::
     A sampler descriptor provided at descriptor set layout creation time,
-    and that is used for that binding in all descriptor sets created from
+    and that is used for that binding in all descriptor sets allocated from
     the layout, and cannot be changed.
 
 Implicitly-Enabled Layer::

doc/specs/vulkan/chapters/cmdbuffers.txt

@@ -136,7 +136,7 @@ include::../api/enums/VkCommandPoolCreateFlagBits.txt[]
      only be reset in bulk by calling fname:vkResetCommandPool.
   * pname:queueFamilyIndex designates a queue family as described in section
     <<devsandqueues-queueprops,Queue Family Properties>>. All command
-    buffers created from this command pool must: be submitted on queues
+    buffers allocated from this command pool must: be submitted on queues
     from the same queue family.
 
 include::../validity/structs/VkCommandPoolCreateInfo.txt[]
@@ -327,18 +327,21 @@ be inherited from the primary command buffer:
 
 include::../api/structs/VkCommandBufferInheritanceInfo.txt[]
 
-  * pname:renderPass is a sname:VkRenderPass object that must: be
+  * pname:renderPass is a sname:VkRenderPass object defining which
-    <<renderpass-compatibility, compatible>> with the one that is bound when
+    render passes the sname:VkCommandBuffer will be
-    the sname:VkCommandBuffer is executed if the command buffer was
+    <<renderpass-compatibility, compatible>> with and can: be executed
-    allocated with the
+    within. If the sname:VkCommandBuffer will not be executed within a
-    ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT set.
+    render pass instance, pname:renderPass is ignored.
   * pname:subpass is the index of the subpass within pname:renderPass that
-    the sname:VkCommandBuffer will be rendering against if it was allocated
+    the sname:VkCommandBuffer will be executed within. If the
-    with the ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT set.
+    sname:VkCommandBuffer will not be executed within a render pass
-  * pname:framebuffer refers to the sname:VkFramebuffer object that the
+    instance, pname:subpass is ignored.
-    sname:VkCommandBuffer will be rendering to if it was allocated with
+  * pname:framebuffer optionally refers to the sname:VkFramebuffer
-    the ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT set. It can:
+    object that the sname:VkCommandBuffer will be rendering to if it is
-    be dlink:VK_NULL_HANDLE if the framebuffer is not known.
+    executed within a render pass instance. It can:
+    be dlink:VK_NULL_HANDLE if the framebuffer is not known, or if the
+    sname:VkCommandBuffer will not be executed within a render pass
+    instance.
 +
 [NOTE]
 .Note
@@ -543,8 +546,7 @@ primary command buffer with the command:
 include::../api/protos/vkCmdExecuteCommands.txt[]
 
   * pname:commandBuffer is a handle to a primary command buffer that the
-    secondary command buffers are submitted to, and must: be in the
+    secondary command buffers are executed in.
-    recording state.
   * pname:commandBufferCount is the length of the pname:pCommandBuffers
     array.
   * pname:pCommandBuffers is an array of secondary command buffer handles,

doc/specs/vulkan/chapters/descriptorsets.txt

@@ -1433,7 +1433,21 @@ include::../api/structs/VkDescriptorBufferInfo.txt[]
   * pname:range is the size in bytes that is used for this descriptor
     update, or ename:VK_WHOLE_SIZE to use the range from pname:offset to the
     end of the buffer.
-
++
+--
+[NOTE]
+.Note
+====
+When using ename:VK_WHOLE_SIZE, the effective range mustnot: be larger
+than the maximum range for the descriptor type
+(<<features-limits-maxUniformBufferRange, maxUniformBufferRange>> or
+<<features-limits-maxStorageBufferRange, maxStorageBufferRange>>). This
+means that ename:VK_WHOLE_SIZE is not typically useful in the common
+case where uniform buffer descriptors are suballocated from a buffer
+that is much larger than pname:maxUniformBufferRange.
+====
+--
++
 For ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC and
 ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC descriptor types,
 pname:offset is the base offset from which the dynamic offset is applied and

doc/specs/vulkan/chapters/interfaces.txt

@@ -379,7 +379,7 @@ constant interface and the descriptor set interface.
 === Push Constant Interface
 
 The shader variables defined with a storage class of code:PushConstant
-that are statically used by the shader entry points for the pipeline
+that are statically used by the shader entry-points for the pipeline
 define the _push constant interface_. They must: be:
 
   * typed as code:OpTypeStruct,
@@ -389,7 +389,7 @@ define the _push constant interface_. They must: be:
     <<interfaces-resources-layout,Offset and Stride Assignment>>.
 
 There must: be no more than one push constant block statically used per
-shader entry point.
+shader entry-point.
 
 Each variable in a push constant block must: be placed at an code:Offset
 such that the entire constant value is entirely contained within the
@@ -410,7 +410,7 @@ only be accessed with dynamically uniform indices.
 The _descriptor set interface_ is comprised of the shader variables with the
 storage class of code:Uniform or code:UniformConstant (including the variables
 in the <<interfaces-inputattachment,fragment input attachment interface>>)
-that are statically used by the shader entry points for the pipeline.
+that are statically used by the shader entry-points for the pipeline.
 
 These variables must: have code:DescriptorSet and code:Binding decorations
 specified, which are assigned and matched with the
@@ -551,7 +551,7 @@ that was specified in slink:VkPipelineLayoutCreateInfo.
 
 The range of descriptor sets is between zero and
 pname:maxBoundDescriptorSets minus one. If a descriptor set value
-is statically used by an entry point there must: be an associated
+is statically used by an entry-point there must: be an associated
 pname:pSetLayout in the corresponding pipeline layout as described in
 <<descriptorsets-pipelinelayout-consistency,Pipeline Layouts consistency>>.
 
@@ -572,12 +572,12 @@ There is a limit on the number of resources of each type that can: be
 accessed by a pipeline stage as shown in
 <<interfaces-resources-limits,Shader Resource Limits>>.
 The ``Resources Per Stage'' column gives the limit on the number each type
-of resource that can: be statically used for an entry point in any given
+of resource that can: be statically used for an entry-point in any given
 stage in a pipeline. The ``Resource Types'' column lists which resource
 types are counted against the limit. Some resource types count against
 multiple limits.
 
-If multiple entry points in the same pipeline refer to the same set and
+If multiple entry-points in the same pipeline refer to the same set and
 binding, all variable definitions with that code:DescriptorSet and
 code:Binding must: have the same basic type.
 
@@ -679,7 +679,7 @@ The *std430 layout* in GLSL satisfies these rules.
 == Built-In Variables
 
 Built-in variables are accessed in shaders by declaring a variable decorated
-using a code:BuiltIn decoration. The meaning of each code:BuiltIn decoration
+with a code:BuiltIn decoration. The meaning of each code:BuiltIn decoration
 is as follows. In the remainder of this section, the name of a built-in is
 used interchangeably with a term equivalent to a variable decorated with
 that particular built-in. Built-ins that represent integer values can: be
@@ -687,121 +687,155 @@ declared as either signed or unsigned 32-bit integers.
 
 code:ClipDistance::
 
-Variables decorated with the code:ClipDistance decoration provide the
+Decorating a variable with the code:ClipDistance built-in decoration will make
-mechanism for controlling user clipping. Declared as an array, the i^th^
+that variable contain the mechanism for controlling user clipping.
-element of the variable decorated as code:ClipDistance specifies a clip
+code:ClipDistance is an array such that the i^th^ element of the array specifies
-distance for plane i. A clip distance of 0 means the vertex is on the plane,
+the clip distance for plane i. A clip distance of 0 means the vertex is on the
-a positive distance means the vertex is inside the clip half-space, and a
+plane, a positive distance means the vertex is inside the clip half-space, and a
 negative distance means the point is outside the clip half-space.
 +
-The code:ClipDistance array is explicitly sized by the shader.
+The code:ClipDistance decoration must: be used only within vertex, fragment,
+tessellation control, tessellation evaluation, and geometry shaders.
 +
-The code:ClipDistance decoration can: be applied to array inputs in
+In vertex shaders, any variable decorated with code:ClipDistance must: be
-tessellation control, tessellation evaluation and geometry shader stages
+declared using the output storage class.
-which will contain the values written by the previous stage. It can: be
-applied to outputs in vertex, tessellation evaluation and geometry shaders.
-In the last vertex processing stage, these values will be linearly
-interpolated across the primitive and the portion of the primitive with
-interpolated distances less than 0 will be considered outside the clip
-volume.
 +
-In the fragment shader, the code:ClipDistance decoration can: be applied to
+In fragment shaders, any variable decorated with code:ClipDistance must: be
-an array of floating-point input variables and contains the linearly
+declared using the input storage class.
-interpolated values described above.
 +
-code:ClipDistance mustnot: be used in compute shaders.
+In tessellation control, tessellation evaluation, or geometry shaders, any
+variable decorated with code:ClipDistance must: not be in a storage class other
+than input or output.
 +
-code:ClipDistance must: be declared as an array of 32-bit floating-point
+Any variable decorated with code:ClipDistance must: be declared as an array of
-values.
+32-bit floating-point values.
-
-code:CullDistance::
-
-A variable decorated as code:CullDistance provides a mechanism for a vertex
-processing stage to reject an entire primitive. code:CullDistance can: be
-applied to an array variable. If any member of this array is assigned a
-negative value for all vertices belonging to a primitive, then the primitive
-is discarded before rasterization. code:CullDistance can: be applied to an
-output variable in the last vertex processing stage (vertex, tessellation
-evaluation or geometry shader).
-+
-If applied to an input variable, that variable will contain the
-corresponding output in the previous shader stage. code:CullDistance
-mustnot: be applied to an input in the vertex shader or to an output in the
-fragment shader, and mustnot: be used in compute shaders.
-+
-In fragment shaders, the values of the code:CullDistance array are linearly
-interpolated across each primitive.
-+
-code:CullDistance must: be declared as an array of 32-bit floating-point
-values.
-
-code:FragCoord::
-
-This variable contains the framebuffer coordinate
-latexmath:[$(x,y,z,\frac{1}{w})$] of the fragment being processed. The (x,y)
-coordinate (0,0) is the upper left corner of the upper left pixel in the
-framebuffer. The x and y components of code:FragCoord reflect
-the location of the center of the pixel
-(latexmath:[$(0.5,0.5)$]) when sample shading is not enabled, and the
-location of the sample corresponding to the shader invocation when using
-sample shading.
-+
-The z component of code:FragCoord is the interpolated depth value of the
-primitive, and the w component is the interpolated
-latexmath:[$\frac{1}{w}$].
-+
-The code:FragCoord decoration must: be used only within fragment shaders. The
-code:Centroid interpolation decoration is ignored on code:FragCoord.
-+
-code:FragCoord must: be declared as a four-component vector of 32-bit
-floating-point values.
-
-code:FragDepth::
-
-Writing to an output variable decorated with code:FragDepth from the
-fragment shader establishes a new depth value for all samples covered by the
-fragment. This value will be used for depth testing and, if the depth test
-passes, any subsequent write to the depth/stencil attachment. To write to
-code:FragDepth, a shader must: declare the code:DepthReplacing execution
-mode. If a shader declares the code:DepthReplacing execution mode and there
-is an execution path through the shader that does not set code:FragDepth,
-then the fragment's depth value is undefined for executions of the shader
-that take that path.
-+
-The code:FragDepth decoration must: be used only within fragment shaders.
-+
-code:FragDepth must: be declared as a scalar 32-bit floating-point value.
-
-code:FrontFacing::
-
-The code:FrontFacing decoration can: be applied to an input variable in the
-fragment shader. This variable is non-zero if the current
-fragment is considered to be part of a
-<<primsrast-polygons-basic,front-facing>> primitive and is zero if the
-fragment is considered to be part of a back-facing primitive.
-+
---
-The code:FrontFacing decoration is not available to shader stages other than
-fragment.
-
-code:FrontFacing must: be declared as a scalar 32-bit integer.
 
 [NOTE]
 .Note
 ====
-In GLSL, code:gl_FrontFacing is declared as a code:bool. To achieve
+The array variable decorated with code:ClipDistance is explicitly sized by the
-similar semantics in SPIR-V, a variable of code:OpTypeBool can: be declared
+shader.
-and initialized as the result of the code:OpINotEqual operation with the
-operands of the code:FrontFacing variable and an appropriately typed
-constant zero.
 ====
---
+
+[NOTE]
+.Note
+====
+In the last vertex processing stage, these values will be linearly interpolated
+across the primitive and the portion of the primitive with interpolated
+distances less than 0 will be considered outside the clip volume. If
+code:ClipDistance is then used by a fragment shader, code:ClipDistance contains
+these linearly interpolated values.
+====
+
+code:CullDistance::
+
+Decorating a variable with the code:CullDistance built-in decoration will make
+that variable contain the mechanism for controlling user culling. If any member
+of this array is assigned a negative value for all vertices belonging to a
+primitive, then the primitive is discarded before rasterization.
++
+The code:CullDistance decoration must: be used only within vertex, fragment,
+tessellation control, tessellation evaluation, and geometry shaders.
++
+In vertex shaders, any variable decorated with code:CullDistance must: be
+declared using the output storage class.
++
+In fragment shaders, any variable decorated with code:CullDistance must: be
+declared using the input storage class.
++
+In tessellation control, tessellation evaluation, or geometry shaders, any
+variable decorated with code:CullDistance must: not be declared in a storage
+class other than input or output.
++
+Any variable decorated with code:CullDistance must: be declared as an array of
+32-bit floating-point values.
+
+[NOTE]
+.Note
+====
+In fragment shaders, the values of the code:CullDistance array are linearly
+interpolated across each primitive.
+====
+
+[NOTE]
+.Note
+====
+If code:CullDistance decorates an input variable, that variable will contain the
+corresponding value from the code:CullDistance decorated output variable from
+the previous shader stage.
+====
+
+code:FragCoord::
+
+Decorating a variable with the code:FragCoord built-in decoration will make that
+variable contain the framebuffer coordinate latexmath:[$(x,y,z,\frac{1}{w})$] of
+the fragment being processed. The latexmath:[$(x,y)$] coordinate
+latexmath:[$(0,0)$] is the upper left corner of the upper left pixel in the
+framebuffer.
++
+When sample shading is enabled, the latexmath:[$x$] and latexmath:[$y$]
+components of code:FragCoord reflect the location of the sample corresponding
+to the shader invocation.
++
+When sample shading is not enabled, the x and y components of code:FragCoord
+reflect the location of the center of the pixel, latexmath:[$(0.5,0.5)$].
++
+The latexmath:[$z$] component of code:FragCoord is the interpolated depth value
+of the primitive.
++
+The latexmath:[$w$] component is the interpolated latexmath:[$\frac{1}{w}$].
++
+The code:FragCoord decoration must: be used only within fragment shaders.
++
+The variable decorated with code:FragCoord must: be declared using the input
+storage class.
++
+The code:Centroid interpolation decoration is ignored on code:FragCoord.
++
+The variable decorated with code:FragCoord must: be declared as a four-component
+vector of 32-bit floating-point values.
+
+code:FragDepth::
+
+Decorating a variable with the code:FragDepth built-in decoration will make that
+variable contain the new depth value for all samples covered by the fragment.
+This value will be used for depth testing and, if the depth test passes, any
+subsequent write to the depth/stencil attachment.
++
+To write to code:FragDepth, a shader must: declare the code:DepthReplacing
+execution mode. If a shader declares the code:DepthReplacing execution mode and
+there is an execution path through the shader that does not set code:FragDepth,
+then the fragment's depth value is undefined for executions of the shader that
+take that path.
++
+The code:FragDepth decoration must: be used only within fragment shaders.
++
+The variable decorated with code:FragDepth must: be declared using the output
+storage class.
++
+The variable decorated with code:FragDepth must: be declared as a scalar 32-bit
+floating-point value.
+
+code:FrontFacing::
+
+Decorating a variable with the code:FrontFacing built-in decoration will make
+that variable contain whether a primitive is front or back facing. This variable
+is non-zero if the current fragment is considered to be part of a
+<<primsrast-polygons-basic,front-facing>> primitive and is zero if the fragment
+is considered to be part of a back-facing primitive.
++
+The code:FrontFacing decoration must: be used only within fragment shaders.
++
+The variable decorated with code:FrontFacing must: be declared using the
+input storage class.
++
+The variable decorated with code:FrontFacing must: be declared as a boolean.
 
 code:GlobalInvocationId::
 
-The code:GlobalInvocationId built-in decoration can: be applied to a variable
+Decorating a variable with the code:GlobalInvocationId built-in decoration will
-that represents the location of the current invocation within the global
+make that variable contain the location of the current invocation within the
-workgroup. Each component is equal to the index of the local workgroup
+global workgroup. Each component is equal to the index of the local workgroup
 multiplied by the size of the local workgroup plus code:LocalInvocationId.
 +
 The code:GlobalInvocationId decoration must: be used only within compute
@@ -811,20 +845,25 @@ The variable decorated with code:GlobalInvocationId must: be declared using the
 input storage class.
 +
 The variable decorated with code:GlobalInvocationId must: be declared as a
-three-component vector of 32-bit unsigned integers.
+three-component vector of 32-bit integers.
 
 code:HelperInvocation::
 
-This variable is non-zero if the fragment being shaded is a helper
+Decorating a variable with the code:HelperInvocation built-in decoration will
-invocation and zero otherwise. A helper invocation is an invocation of
+make that variable contain whether the current invocation is a helper
+invocation. This variable is non-zero if the current fragment being shaded is a
+helper invocation and zero otherwise. A helper invocation is an invocation of
 the shader that is produced to satisfy internal requirements such as the
 generation of derivatives.
 +
---
 The code:HelperInvocation decoration must: be used only within fragment
 shaders.
-
++
-code:HelperInvocation must: be declared as a scalar 32-bit integer.
+The variable decorated with code:HelperInvocation must: be declared using the
+input storage class.
++
+The variable decorated with code:HelperInvocation must: be declared as a
+boolean.
 
 [NOTE]
 .Note
@@ -833,73 +872,78 @@ It is very likely that a helper invocation will have a value of
 code:SampleMask fragment shader input value that is zero.
 ====
 
-[NOTE]
-.Note
-====
-In GLSL, code:HelperInvocation is declared as a code:bool. To achieve
-similar semantics in SPIR-V, a variable of code:OpTypeBool can: be declared
-and initialized as the result of the code:OpINotEqual operation with the
-operands of the code:HelperInvocation variable and an appropriately typed
-constant zero.
-====
---
-
 code:InvocationId::
 
-In a geometry shader, an input variable decorated with the code:InvocationId
+Decorating a variable with the code:InvocationId built-in decoration will make
-decoration contains the index of the current shader invocation, which ranges
+that variable contain the index of the current shader invocation in a geometry
+shader, or the index of the output patch vertex in a tessellation control
+shader.
++
+In a geometry shader, the index of the current shader invocation ranges
 from zero to the number of <<geometry-invocations,instances>> declared in
 the shader minus one. If the instance count of the geometry shader is one or
 is not specified, then code:InvocationId will be zero.
 +
-In tessellation control shaders, and input variable decorated with the
+The code:InvocationId decoration must: be used only within tessellation control
-code:InvocationId decoration contains the index of the output patch vertex
+and geometry shaders.
-assigned to the tessellation control shader invocation.
 +
-The code:InvocationId decoration mustnot: be used in vertex, tessellation
+The variable decorated with code:InvocationId must: be declared using the input
-evaluation, fragment, or compute shaders.
+storage class.
 +
-code:InvocationId must: be declared as a scalar 32-bit integer.
+The variable decorated with code:InvocationId must: be declared as a scalar
+32-bit integer.
 
 code:InstanceIndex::
 
-The code:InstanceIndex decoration can: be applied to a vertex shader input
+Decorating a variable with the code:InstanceIndex built-in decoration will make
-which will be filled with the index of the instance that is being processed
+that variable contain the index of the instance that is being processed by the
-by the current vertex shader invocation. code:InstanceIndex
+current vertex shader invocation. code:InstanceIndex begins at the
-begins at the pname:firstInstance parameter to flink:vkCmdDraw
+pname:firstInstance parameter to flink:vkCmdDraw or flink:vkCmdDrawIndexed or at
-or flink:vkCmdDrawIndexed or at the pname:firstInstance member
+the pname:firstInstance member of a structure consumed by
-of a structure consumed by flink:vkCmdDrawIndirect or
+flink:vkCmdDrawIndirect or flink:vkCmdDrawIndexedIndirect.
-flink:vkCmdDrawIndexedIndirect.
 +
-The code:InstanceIndex decoration mustnot: be used in any shader stage other
+The code:InstanceIndex decoration must: be used only within vertex shaders.
-than vertex.
 +
-code:InstanceIndex must: be declared as a scalar 32-bit integer.
+The variable decorated with code:InstanceIndex must: be declared using the
+input storage class.
++
+The variable decorated with code:InstanceIndex must: be declared as a
+scalar 32-bit integer.
 
 code:Layer::
 
-The code:Layer decoration can: be applied to an output variable in the
+Decorating a variable with the code:Layer built-in decoration will make that
-geometry shader that is written with the framebuffer layer index to which
+variable contain the select layer of a multi-layer framebuffer attachment.
-the primitive produced by the geometry shader will be directed. If a
++
-geometry shader entry point's interface does not include an output variable
+In a geometry shader, any variable decorated with code:Layer can be written with
-decorated with code:Layer, then the first layer is used. If a geometry
+the framebuffer layer index to which the primitive produced by the geometry
-shader entry point's interface includes an output variable decorated with
+shader will be directed. If a geometry shader entry-point's interface does not
+include a variable decorated with code:Layer, then the first layer is used. If
+a geometry shader entry-point's interface includes a variable decorated with
 code:Layer, it must: write the same value to code:Layer for all output
-vertices of a given primitive. When used in a fragment shader, an input
+vertices of a given primitive.
-variable decorated with code:Layer contains the layer index of the primitive
++
-that the fragment invocation belongs to.
+In a fragment shader, a variable decorated with code:Layer contains the layer
+index of the primitive that the fragment invocation belongs to.
 +
 The code:Layer decoration must: be used only within geometry and fragment
 shaders.
 +
-code:Layer must: be declared as a scalar 32-bit integer.
+In a geometry shader, any variable decorated with code:Layer must: be declared
+using the output storage class.
++
+In a fragment shader, any variable decorated with code:Layer must: be declared
+using the input storage class.
++
+Any variable decorated with code:Layer must: be declared as a scalar 32-bit
+integer.
 
 code:LocalInvocationId::
 
-The code:LocalInvocationId built-in decoration can: be applied to a variable
+Decorating a variable with the code:LocalInvocationId built-in decoration will
-that represents the location of the current compute shader invocation within
+make that variable contain the location of the current compute shader invocation
-the local workgroup. Each component ranges from zero through to the size of the
+within the local workgroup. Each component ranges from zero through to the size
-workgroup in that dimension minus one.
+of the workgroup in that dimension minus one.
 +
 The code:LocalInvocationId decoration must: be used only within compute
 shaders.
@@ -908,7 +952,7 @@ The variable decorated with code:LocalInvocationId must: be declared using the
 input storage class.
 +
 The variable decorated with code:LocalInvocationId must: be declared as a
-three-component vector of 32-bit unsigned integers.
+three-component vector of 32-bit integers.
 
 [NOTE]
 .Note
@@ -922,11 +966,12 @@ code:LocalInvocationId.y and code:LocalInvocationId.z will be zero.
 
 code:NumWorkgroups::
 
-The code:NumWorkgroups built-in decoration can: be applied to a variable that
+Decorating a variable with the code:NumWorkgroups built-in decoration will make
-represents the number of local workgroups that are part of the dispatch that the
+that variable contain the number of local workgroups that are part of the
-invocation belongs to. Each component is equal to the values of the parameters
+dispatch that the invocation belongs to. Each component is equal to the values
-passed into flink:vkCmdDispatch or read from the sname:VkDispatchIndirectCommand
+of the parameters passed into flink:vkCmdDispatch or read from the
-structure read through a call to flink:vkCmdDispatchIndirect.
+sname:VkDispatchIndirectCommand structure read through a call to
+flink:vkCmdDispatchIndirect.
 +
 The code:NumWorkgroups decoration must: be used only within compute shaders.
 +
@@ -938,121 +983,169 @@ three-component vector of 32-bit integers.
 
 code:PatchVertices::
 
-An input variable decorated with code:PatchVertices in the tessellation
+Decorating a variable with the code:PatchVertices built-in decoration will make
-control or evaluation shader is an integer specifying the number of
+that variable contain the number of vertices in the input patch being processed
-vertices in the input patch being processed by the shader. A single
+by the shader. A single tessellation control or tessellation evaluation shader
-tessellation control or evaluation shader can: read patches of differing
+can: read patches of differing sizes, so the value of the code:PatchVertices
-sizes, so the code:PatchVertices variable may: differ between patches.
+variable may: differ between patches.
 +
 The code:PatchVertices decoration must: be used only within tessellation
-control and evaluation shaders.
+control and tessellation evaluation shaders.
 +
-code:PatchVertices must: be declared as scalar 32-bit integer.
+The variable decorated with code:PatchVertices must: be declared using the input
+storage class.
++
+The variable decorated with code:PatchVertices must: be declared as scalar
+32-bit integer.
 
 code:PointCoord::
 
-During point rasterization, a variable decorated with code:PointCoord
+Decorating a variable with the code:PointCoord built-in decoration will make
-contains the coordinate of the current fragment within the point being
+that variable contain the coordinate of the current fragment within the point
-rasterized, normalized to the size of the point with origin in the upper
+being rasterized, normalized to the size of the point with origin in the upper
 left corner of the point, as described in <<primsrast-points-basic,Basic
 Point Rasterization>>. If the primitive the fragment shader invocation
-belongs to is not a point, then code:PointCoord is undefined.
+belongs to is not a point, then the variable decorated with code:PointCoord
+contains an undefined value.
 +
---
 The code:PointCoord decoration must: be used only within fragment shaders.
-
++
-code:PointCoord must: be declared as two-component vector of 32-bit
+The variable decorated with code:PointCoord must: be declared using the
-floating-point values.
+input storage class.
++
+The variable decorated with code:PointCoord must: be declared as two-component
+vector of 32-bit floating-point values.
 
 [NOTE]
 .Note
 ====
 Depending on how the point is rasterized, code:PointCoord may: never
-reach (0,0) or (1,1).
+reach latexmath:[$(0,0)$] or latexmath:[$(1,1)$].
 ====
---
 
 code:PointSize::
 
-The code:PointSize built-in decoration is used to pass the size of point
+Decorating a variable with the code:PointSize built-in decoration will make that
-primitives between shader stages. It can: be applied to inputs to
+variable contain the size of point primitives. The value written to the variable
-tessellation control and geometry shaders. It can: be applied to output
+decorated with code:PointSize by the last vertex processing stage in the
-variables in vertex, tessellation evaluation and geometry shaders. The value
+pipeline is used as the framebuffer-space size of points produced by
-written to the variable decorated as code:PointSize by the last vertex
+rasterization.
-processing stage in the pipeline is used as the framebuffer space size of
-points produced by rasterization. As an input, it reflects the value written
-to the output decorated with code:PointSize in the previous shader stage.
 +
-The code:PointSize decoration mustnot: be applied to inputs in the vertex
+The code:PointSize decoration must: be used only within vertex, tessellation
-shader and mustnot: be used in fragment or compute shaders.
+control, tessellation evaluation, and geometry shaders.
 +
-code:PointSize must: be declared as a scalar 32-bit floating-point value.
+In a vertex shader, any variable decorated with code:PointSize must: be
+declared using the output storage class.
++
+In a tesselation control, tessellation evaluation, or geometry shader, any
+variable decorated with code:PointSize must: be declared using either the
+input or output storage class.
++
+Any variable decorated with code:PointSize must: be declared as a scalar 32-bit
+floating-point value.
+
+[NOTE]
+.Note
+====
+When code:PointSize decorates a variable in the input storage class, it contains
+the data written to the output variable decorated with code:PointSize from the
+previous shader stage.
+====
 
 code:Position::
 
-The code:Position built-in decoration can: be used on variables declared as
+Decorating a variable with the code:Position built-in decoration will make that
-input to tessellation control, tessellation evaluation and geometry shaders.
+variable contain the position of the current vertex. In the last vertex
-It can: be used on variables declared as outputs in the vertex, tessellation
+processing stage, the value of the variable decorated with code:Position is used
-control, tessellation evaluation and geometry shaders. As an input, it
+in subsequent primitive assembly, clipping, and rasterization operations.
-contains the data written to the output variable decorated as code:Position
-in the previous shader stage. As an output, the data written to a variable
-decorated as code:Position is passed to the next shader stage. In the last
-vertex processing stage, the output position is used in subsequent primitive
-assembly, clipping and rasterization operations.
 +
-Variables decorated as code:Position mustnot: be used as inputs in vertex
+The code:Position decoration must: be used only within vertex, tessellation
-shaders and mustnot: be used in fragment or compute shaders.
+control, tessellation evaluation, and geometry shaders.
 +
-code:Position must: be declared as a four-component vector of 32-bit
+In a vertex shader, any variable decorated with code:Position must: be declared
-floating-point values.
+using the output storage class.
++
+In a tesselation control, tessellation evaluation, or geometry shader, any
+variable decorated with code:Position must: not be declared in a storage class
+other than input or output.
++
+Any variable decorated with code:Position must: be declared as a four-component
+vector of 32-bit floating-point values.
+
+[NOTE]
+.Note
+====
+When code:Position decorates a variable in the input storage class, it contains
+the data written to the output variable decorated with code:Position from the
+previous shader stage.
+====
 
 code:PrimitiveId::
 
-When the code:PrimitiveId decoration is applied to an input variable in the
+Decorating a variable with the code:PrimitiveId built-in decoration will make
-tessellation control or tessellation evaluation shader, it will be filled
+that variable contain the index of the current primitive.
-with the index of the patch within the current set of rendering primitives
-that corresponds to the shader invocation.
 +
-When the code:PrimitiveId decoration is applied to an input variable in the
+In tessellation control and tessellation evaluation shaders, it will contain
-geometry shader, it will be filled with the number of primitives presented
+the index of the patch within the current set of rendering primitives that
-as input to the geometry shader since the current set of rendering
+correspond to the shader invocation.
-primitives was started. When code:PrimitiveId is applied to an output in the
-geometry shader, the resulting value is seen as an input to the fragment
-shader.
 +
-When code:PrimitiveId is applied to an input in the fragment shader, it will
+In a geometry shader, it will contain the number of primitives presented as
-be filled with the primitive index written by the geometry shader if a
+input to the shader since the current set of rendering primitives was started.
-geometry shader is present, or with the value that would have been presented
-as input to the geometry shader had it been present. If a geometry shader is
-present and the fragment shader reads from an input variable decorated with
-code:PrimitiveId, then the geometry shader must: write to an output variable
-decorated with code:PrimitiveId in all execution paths; otherwise the
-code:PrimitiveId input in the fragment shader is undefined.
 +
-The code:PrimitiveId decoration mustnot: be used in vertex or compute
+In a fragment shader, it will contain the primitive index written by the
-shaders. code:PrimitiveId mustnot: be used on output variables in
+geometry shader if a geometry shader is present, or with the value that would
-tessellation control, tessellation evaluation, or fragment shaders.
+have been presented as input to the geometry shader had it been present.
 +
-code:PrimitiveId must: be declared as scalar 32-bit integer.
+If a geometry shader is present and the fragment shader reads from an input
+variable decorated with code:PrimitiveId, then the geometry shader must: write
+to an output variable decorated with code:PrimitiveId in all execution paths.
++
+The code:PrimitiveId decoration must: be used only within fragment, tessellation
+control, tessellation evaluation, and geometry shaders.
++
+In a fragment, tesselation control or tessellation evaluation shader, any
+variable decorated with code:PrimitiveId must: be declared using the output
+storage class.
++
+In a geometry shader, any variable decorated with code:PrimitiveId must: be
+declared using either the input or output storage class.
++
+Any variable decorated with code:PrimitiveId must: be declared as scalar 32-bit
+integer.
+
+[NOTE]
+.Note
+====
+When the code:PrimitiveId decoration is applied to an output variable in the
+geometry shader, the resulting value is seen through the code:PrimitiveId
+decorated input variable in the fragment shader.
+====
 
 code:SampleId::
 
-The code:SampleId decoration can: be applied to an integer input variable in
+Decorating a variable with the code:SampleId built-in decoration will make that
-the fragment shader. This variable will contain the zero-based index of the
+variable contain the zero-based index of the sample the invocation corresponds to.
-sample the invocation corresponds to. code:SampleId ranges from
+code:SampleId ranges from zero to the number of samples in the framebuffer
-zero to the number of samples in the framebuffer minus one. If a fragment
+minus one. If a fragment shader entry-point's interface includes an input
-shader entry point's interface includes an input variable decorated with
+variable decorated with code:SampleId, per-sample shading is enabled for draws
-code:SampleId, per-sample shading is enabled for draws that use that
+that use that fragment shader.
-fragment shader.
 +
-code:SampleId is not available in shader stages other than fragment.
+The code:SampleId decoration must: be used only within fragment shaders.
 +
-code:SampleId must: be declared as a scalar 32-bit integer.
+The variable decorated with code:SampleId must: be declared using the input
+storage class.
++
+The variable decorated with code:SampleId must: be declared as a scalar 32-bit
+integer.
 
 code:SampleMask::
 
-A fragment input variable decorated with code:SampleMask will contain a
+Decorating a variable with the code:SampleMask built-in decoration will make
-bitmask of the set of samples covered by the primitive generating the
+any variable contain the sample coverage mask for the current fragment shader
+invocation.
++
+A variable in the input storage class decorated with code:SampleMask will
+contain a bitmask of the set of samples covered by the primitive generating the
 fragment during rasterization. It has a sample bit set if and only if the
 sample is considered covered for this fragment shader invocation.
 code:SampleMask[] is an array of integers. Bits are mapped to samples in a
@@ -1065,10 +1158,10 @@ specifies the subset of the covered samples for the fragment that correspond
 to the invocation. In this case, the bit corresponding to each covered
 sample will be set in exactly one fragment shader invocation.
 +
-A fragment output variable decorated with code:SampleMask is an array of
+A variable in the output storage class decorated with code:SampleMask is an
-integers forming a bit array in a manner similar an input variable decorated
+array of integers forming a bit array in a manner similar an input variable
-with code:SampleMask, but where each bit represents coverage as computed by
+decorated with code:SampleMask, but where each bit represents coverage as
-the shader. Modifying the sample mask by writing zero to a bit of
+computed by the shader. Modifying the sample mask by writing zero to a bit of
 code:SampleMask causes the sample to be considered uncovered. However,
 setting sample mask bits to one will never enable samples not covered by the
 original primitive. If the fragment shader is being evaluated at any
@@ -1077,82 +1170,113 @@ to the current fragment shader invocation are ignored. This array must: be
 sized in the fragment shader either implicitly or explicitly, to be no
 larger than the implementation-dependent maximum sample-mask (as an array of
 32-bit elements), determined by the maximum number of samples. If a fragment
-shader entry point's interface includes an output variable decorated with
+shader entry-point's interface includes an output variable decorated with
 code:SampleMask, the sample mask will be undefined for any array elements of
 any fragment shader invocations that fail to assign a value. If a fragment
-shader entry point's interface does not include an output variable decorated
+shader entry-point's interface does not include an output variable decorated
 with code:SampleMask, the sample mask has no effect on the processing of a
 fragment.
 +
 The code:SampleMask decoration must: be used only within fragment shaders.
 +
-code:SampleMask must: be declared as an array of 32-bit integers.
+Any variable decorated with code:SampleMask must: be declared using either the
+input or output storage class.
++
+Any variable decorated with code:SampleMask must: be declared as an array of
+32-bit integers.
 
 code:SamplePosition::
 
-This variable contains the sub-pixel position of the sample being shaded.
+Decorating a variable with the code:SamplePosition built-in decoration will make
-The top left of the pixel is considered to be at coordinate (0,0) and the
+that variable contain the sub-pixel position of the sample being shaded.
-bottom right of the pixel is considered to be at coordinate (1,1). If a
+The top left of the pixel is considered to be at coordinate latexmath:[$(0,0)$]
-fragment shader entry point's interface includes an input variable decorated
+and the bottom right of the pixel is considered to be at coordinate
-with code:SamplePosition, per-sample shading is enabled for draws that use
+latexmath:[$(1,1)$]. If a fragment shader entry-point's interface includes an
-that fragment shader.
+input variable decorated with code:SamplePosition, per-sample shading is enabled
+for draws that use that fragment shader.
 +
 The code:SamplePosition decoration must: be used only within fragment shaders.
 +
-code:SamplePosition must: be declared as a two-component vector of
+The variable decorated with code:SamplePosition must: be declared using the
-floating-point values.
+input storage class.
++
+The variable decorated with code:SamplePosition must: be declared as a
+two-component vector of 32-bit floating-point values.
 
 code:TessCoord::
 
-The code:TessCoord is applied to an input variable in tessellation
+Decorating a variable with the code:TessCoord built-in decoration will make that
-evaluation shaders and specifies the three-dimensional (u,v,w) barycentric
+variable contain the three-dimensional latexmath:[$(u,v,w)$] barycentric
-coordinate of the tessellated vertex within the patch. u, v,
+coordinate of the tessellated vertex within the patch. latexmath:[$u$],
-and w are in the range latexmath:[$[0,1\]$] and vary linearly across the
+latexmath:[$v$], and latexmath:[$w$] are in the range latexmath:[$[0,1\]$] and
-primitive being subdivided. For the tessellation modes of code:Quads or
+vary linearly across the primitive being subdivided. For the tessellation modes
-code:IsoLines, the third component is always zero.
+of code:Quads or code:IsoLines, the third component is always zero.
 +
 The code:TessCoord decoration must: be used only within tessellation
 evaluation shaders.
 +
-code:TessCoord must: be declared as three-component vector of 32-bit
+The variable decorated with code:TessCoord must: be declared using the
-floating-point values.
+input storage class.
++
+The variable decorated with code:TessCoord must: be declared as three-component
+vector of 32-bit floating-point values.
 
 code:TessLevelOuter::
 
-The code:TessLevelOuter decoration is used in tessellation control
+Decorating a variable with the code:TessLevelOuter built-in decoration will make
-shaders to decorate an output variable to contain the outer tessellation
+that variable contain the outer tessellation levels for the current patch.
-factors for the resulting patch. These values are used by the tessellator
++
-to control primitive tessellation and can: be read by
+In tessellation control shaders, the variable decorated with code:TessLevelOuter
-tessellation evaluation shaders. When applied to an input variable in a
+can: be written to which controls the tessellation factors for the resulting
-tessellation evaluation shader, the shader can: read the values written by
+patch. These values are used by the tessellator to control primitive
-the tessellation control shader.
+tessellation and can: be read by tessellation evaluation shaders.
++
+In tessellation evaluation shaders, the variable decorated with
+code:TessLevelOuter can: read the values written by the tessellation control
+shader.
 +
 The code:TessLevelOuter decoration must: be used only within
-tessellation control and evaluation shaders.
+tessellation control and tessellation evaluation shaders.
 +
-code:TessLevelOuter must: be declared as an array of size four,
+In a tessellation control shader, any variable decorated with
-containing 32-bit floating-point values.
+code:TessLevelOuter must: be declared using the output storage class.
++
+In a tessellation evaluation shader, any variable decorated with
+code:TessLevelOuter must: be declared using the input storage class.
++
+Any variable decorated with code:TessLevelOuter must: be declared as an array
+of size four, containing 32-bit floating-point values.
 
 code:TessLevelInner::
 
-The code:TessLevelInner decoration is used in tessellation control
+Decorating a variable with the code:TessLevelInner built-in decoration will make
-shaders to decorate an output variable to contain the inner tessellation
+that variable contain the inner tessellation levels for the current patch.
-factors for the resulting patch. These values are used by the tessellator to
++
-control primitive tessellation and can: be read by
+In tessellation control shaders, the variable decorated with code:TessLevelInner
-tessellation evaluation shaders. When applied to an input variable in a
+can: be written to, which controls the tessellation factors for the resulting
-tessellation evaluation shader, the shader can: read the values written by
+patch. These values are used by the tessellator to control primitive
-the tessellation control shader.
+tessellation and can: be read by tessellation evaluation shaders.
++
+In tessellation evaluation shaders, the variable decorated with
+code:TessLevelInner can: read the values written by the tessellation control
+shader.
 +
 The code:TessLevelInner decoration must: be used only within
-tessellation control and evaluation shaders.
+tessellation control and tessellation evaluation shaders.
 +
-code:TessLevelInner must: be declared as an array of size two,
+In a tessellation control shader, any variable decorated with
-containing 32-bit floating-point values.
+code:TessLevelInner must: be declared using the output storage class.
++
+In a tessellation evaluation shader, any variable decorated with
+code:TessLevelInner must: be declared using the input storage class.
++
+Any variable decorated with code:TessLevelInner must: be declared as an array
+of size two, containing 32-bit floating-point values.
 
 code:VertexIndex::
 
-The code:VertexIndex decoration can: be applied to a vertex shader input
+Decorating a variable with the code:VertexIndex built-in decoration will make
-which will be filled with the index of the vertex that is being processed by
+that variable contain the index of the vertex that is being processed by
 the current vertex shader invocation. For non-indexed draws,
 this variable begins at the pname:firstVertex parameter to
 flink:vkCmdDraw or the pname:firstVertex member of a structure consumed by
@@ -1162,39 +1286,58 @@ vertex plus the pname:vertexOffset parameter to
 flink:vkCmdDrawIndexed or the pname:vertexOffset member of the structure
 consumed by flink:vkCmdDrawIndexedIndirect.
 +
-code:VertexIndex starts at the same starting value for each instance.
-+
 The code:VertexIndex decoration must: be used only within vertex shaders.
 +
-code:VertexIndex must: be declared as a 32-bit integer.
+The variable decorated with code:VertexIndex must: be declared using the
+input storage class.
++
+The variable decorated with code:VertexIndex must: be declared as a scalar
+32-bit integer.
+
+[NOTE]
+.Note
+====
+code:VertexIndex starts at the same starting value for each instance.
+====
 
 code:ViewportIndex::
 
-The code:ViewportIndex decoration can: be applied to an output variable in
+Decorating a variable with the code:ViewportIndex built-in decoration will make
-the geometry shader that is written with the viewport index to which the
+that variable contain the index of the viewport.
-primitive produced by the geometry shader will be directed. The selected
++
+In a geometry shader, the variable decorated with code:ViewportIndex can be
+written to with the viewport index to which the primitive produced by the
+geometry shader will be directed. The selected
 viewport index is used to select the viewport transform and scissor
-rectangle. If a geometry shader entry point's interface does not include an
+rectangle. If a geometry shader entry-point's interface does not include a
-output variable decorated with code:ViewportIndex, then the first viewport
+variable decorated with code:ViewportIndex, then the first viewport
-is used. If a geometry shader entry point's interface includes an output
+is used. If a geometry shader entry-point's interface includes a variable
-variable decorated with code:ViewportIndex, it must: write the same value to
+decorated with code:ViewportIndex, it must: write the same value to
-code:ViewportIndex for all output vertices of a given primitive. When used
+code:ViewportIndex for all output vertices of a given primitive.
-in a fragment shader, an input variable decorated with code:ViewportIndex
++
+In a fragment shader, the variable decorated with code:ViewportIndex
 contains the viewport index of the primitive that the fragment invocation
 belongs to.
 +
 The code:ViewportIndex decoration must: be used only within geometry and
 fragment shaders.
 +
-code:ViewportIndex must: be declared as a 32-bit integer.
+In a geometry shader, any variable decorated with code:ViewportIndex must: be
+declared using the output storage class.
++
+In a fragment shader, any variable decorated with code:ViewportIndex must: be
+declared using the input storage class.
++
+Any variable decorated with code:ViewportIndex must: be declared as a scalar
+32-bit integer.
 
 code:WorkgroupId::
 
-The code:WorkgroupId built-in decoration can: be applied to a variable that
+Decorating a variable with the code:WorkgroupId built-in decoration will make
-represents the global workgroup that the current invocation is a member of.
+that variable contain theglobal workgroup that the current invocation is a
-Each component ranges from zero to the values of the parameters passed into
+member of. Each component ranges from zero to the values of the parameters
-flink:vkCmdDispatch or read from the sname:VkDispatchIndirectCommand structure
+passed into flink:vkCmdDispatch or read from the sname:VkDispatchIndirectCommand
-read through a call to flink:vkCmdDispatchIndirect.
+structure read through a call to flink:vkCmdDispatchIndirect.
 +
 The code:WorkgroupId decoration must: be used only within compute shaders.
 +
@@ -1202,14 +1345,14 @@ The variable decorated with code:WorkgroupId must: be declared using the input
 storage class.
 +
 The variable decorated with code:WorkgroupId must: be declared as a
-three-component vector of 32-bit unsigned integers.
+three-component vector of 32-bit integers.
 
 code:WorkgroupSize::
 
-The code:WorkgroupSize built-in decoration can: be applied to an object that
+Decorating a variable with the code:WorkgroupSize built-in decoration will make
-represents the dimensions of a local workgroup. If an object is decorated with
+that variable contain the dimensions of a local workgroup. If an object is
-the code:WorkgroupSize decoration, this must: take precedence over any execution
+decorated with the code:WorkgroupSize decoration, this must: take precedence
-mode set for code:LocalSize.
+over any execution mode set for code:LocalSize.
 +
 The code:WorkgroupSize decoration must: be used only within compute shaders.
 +
@@ -1217,4 +1360,4 @@ The object decorated with code:WorkgroupSize must: be a specialization constant
 or a constant.
 +
 The object decorated with code:WorkgroupSize must: be declared as a
-three-component vector of 32-bit unsigned integers.
+three-component vector of 32-bit integers.

doc/specs/vulkan/chapters/memory.txt

@@ -307,7 +307,7 @@ they are associated with.
 
 If an allocator is provided to a ftext:vkCreate* command, a _compatible_
 allocator must: be provided to the corresponding ftext:vkDestroy* command.
-Two sname:VkAllocationCallbacks structures are compatible if memory created
+Two sname:VkAllocationCallbacks structures are compatible if memory allocated
 with pname:pfnAllocation or pname:pfnReallocation in each can: be freed with
 pname:pfnReallocation or pname:pfnFree in the other. An allocator must: not
 be provided to a ftext:vkDestroy* command if an allocator was not provided
@@ -355,7 +355,7 @@ situations:
   ** fname:vkCreateCommandPool
   ** fname:vkAllocateCommandBuffers for the pname:commandPool member of its
      pname:pAllocateInfo parameter
-  ** any ftext:vkCmd* command whose pname:commandBuffer was created from
+  ** any ftext:vkCmd* command whose pname:commandBuffer was allocated from
      that sname:VkCommandPool
   * Host memory scoped to the lifetime of any other object may: only be
     allocated in that object's ftext:vkCreate* command.
@@ -374,7 +374,7 @@ pname:pfnFree may: be called in the following situations:
   * Host memory scoped to the lifetime of a sname:VkCommandPool may: be
     freed from:
   ** any command that takes the pool as a direct argument
-  ** fname:vkResetCommandBuffer whose pname:commandBuffer was created from
+  ** fname:vkResetCommandBuffer whose pname:commandBuffer was allocated from
      that sname:VkCommandPool
   * Host memory scoped to the lifetime of any other object may: be freed in
     that object's ftext:vkDestroy* command.

doc/specs/vulkan/man/VkCommandBufferInheritanceInfo.txt

@@ -24,18 +24,21 @@ include::../api/structs/VkCommandBufferInheritanceInfo.txt[]
 Members
 -------
 
-  * pname:renderPass is a sname:VkRenderPass object that must: be
+  * pname:renderPass is a sname:VkRenderPass object defining which
-    <<renderpass-compatibility, compatible>> with the one that is bound when
+    render passes the sname:VkCommandBuffer will be
-    the sname:VkCommandBuffer is executed if the command buffer was
+    <<renderpass-compatibility, compatible>> with and can: be executed
-    allocated with the
+    within. If the sname:VkCommandBuffer will not be executed within a
-    ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT set.
+    render pass instance, pname:renderPass is ignored.
   * pname:subpass is the index of the subpass within pname:renderPass that
-    the sname:VkCommandBuffer will be rendering against if it was allocated
+    the sname:VkCommandBuffer will be executed within. If the
-    with the ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT set.
+    sname:VkCommandBuffer will not be executed within a render pass
-  * pname:framebuffer refers to the sname:VkFramebuffer object that the
+    instance, pname:subpass is ignored.
-    sname:VkCommandBuffer will be rendering to if it was allocated with
+  * pname:framebuffer optionally refers to the sname:VkFramebuffer
-    the ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT set. It can:
+    object that the sname:VkCommandBuffer will be rendering to if it is
-    be dlink:VK_NULL_HANDLE if the framebuffer is not known.
+    executed within a render pass instance. It can:
+    be dlink:VK_NULL_HANDLE if the framebuffer is not known, or if the
+    sname:VkCommandBuffer will not be executed within a render pass
+    instance.
 +
 [NOTE]
 .Note

doc/specs/vulkan/man/VkCommandPoolCreateInfo.txt

@@ -47,7 +47,7 @@ include::../api/enums/VkCommandPoolCreateFlagBits.txt[]
      only be reset in bulk by calling fname:vkResetCommandPool.
   * pname:queueFamilyIndex designates a queue family as described in section
     <<devsandqueues-queueprops,Queue Family Properties>>. All command
-    buffers created from this command pool must: be submitted on queues
+    buffers allocated from this command pool must: be submitted on queues
     from the same queue family.
 
 

doc/specs/vulkan/man/VkDescriptorBufferInfo.txt

@@ -29,16 +29,30 @@ Members
   * pname:range is the size in bytes that is used for this descriptor
     update, or ename:VK_WHOLE_SIZE to use the range from pname:offset to the
     end of the buffer.
-
++
-
+--
-Description
+[NOTE]
------------
+.Note
-
+====
+When using ename:VK_WHOLE_SIZE, the effective range mustnot: be larger
+than the maximum range for the descriptor type
+(<<features-limits-maxUniformBufferRange, maxUniformBufferRange>> or
+<<features-limits-maxStorageBufferRange, maxStorageBufferRange>>). This
+means that ename:VK_WHOLE_SIZE is not typically useful in the common
+case where uniform buffer descriptors are suballocated from a buffer
+that is much larger than pname:maxUniformBufferRange.
+====
+--
++
 For ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC and
 ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC descriptor types,
 pname:offset is the base offset from which the dynamic offset is applied and
 pname:range is the static size used for all dynamic offsets.
 
+
+Description
+-----------
+
 include::../validity/structs/VkDescriptorBufferInfo.txt[]
 
 

doc/specs/vulkan/man/vkCmdExecuteCommands.txt

@@ -25,8 +25,7 @@ Parameters
 ----------
 
   * pname:commandBuffer is a handle to a primary command buffer that the
-    secondary command buffers are submitted to, and must: be in the
+    secondary command buffers are executed in.
-    recording state.
   * pname:commandBufferCount is the length of the pname:pCommandBuffers
     array.
   * pname:pCommandBuffers is an array of secondary command buffer handles,

doc/specs/vulkan/validity/protos/vkCmdBeginQuery.txt

@@ -18,9 +18,9 @@ endif::doctype-manpage[]
 * If the <<features-features-occlusionQueryPrecise,precise occlusion queries>> feature is not enabled, or the pname:queryType used to create pname:queryPool was not ename:VK_QUERY_TYPE_OCCLUSION, pname:flags mustnot: contain ename:VK_QUERY_CONTROL_PRECISE_BIT
 * pname:queryPool must: have been created with a pname:queryType that differs from that of any other queries that have been made <<queries-operation-active,active>>, and are currently still active within pname:commandBuffer
 * pname:query must: be less than the number of queries in pname:queryPool
-* If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_OCCLUSION, the sname:VkCommandPool that pname:commandBuffer was created from must: support graphics operations
+* If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_OCCLUSION, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support graphics operations
-* If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate graphics operations, the sname:VkCommandPool that pname:commandBuffer was created from must: support graphics operations
+* If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate graphics operations, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support graphics operations
-* If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate compute operations, the sname:VkCommandPool that pname:commandBuffer was created from must: support compute operations
+* If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate compute operations, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support compute operations
 ifndef::doctype-manpage[]
 ********************************************************************************
 endif::doctype-manpage[]

doc/specs/vulkan/validity/protos/vkCmdBindDescriptorSets.txt

@@ -16,7 +16,7 @@ endif::doctype-manpage[]
 * The sname:VkCommandPool that pname:commandBuffer was allocated from must: support graphics, or compute operations
 * pname:descriptorSetCount must: be greater than `0`
 * Each of pname:commandBuffer, pname:layout, and the elements of pname:pDescriptorSets must: have been created, allocated, or retrieved from the same sname:VkDevice
-* Any given element of pname:pDescriptorSets must: have been created with a sname:VkDescriptorSetLayout that matches (is the same as, or defined identically to) the sname:VkDescriptorSetLayout at set _n_ in pname:layout, where _n_ is the sum of pname:firstSet and the index into pname:pDescriptorSets
+* Any given element of pname:pDescriptorSets must: have been allocated with a sname:VkDescriptorSetLayout that matches (is the same as, or defined identically to) the sname:VkDescriptorSetLayout at set _n_ in pname:layout, where _n_ is the sum of pname:firstSet and the index into pname:pDescriptorSets
 * pname:dynamicOffsetCount must: be equal to the total number of dynamic descriptors in pname:pDescriptorSets
 * The sum of pname:firstSet and pname:descriptorSetCount must: be less than or equal to sname:VkPipelineLayoutCreateInfo::pname:setLayoutCount provided when pname:layout was created
 * pname:pipelineBindPoint must: be supported by the pname:commandBuffer's parent sname:VkCommandPool's queue family

doc/specs/vulkan/validity/protos/vkCmdExecuteCommands.txt

@@ -14,10 +14,10 @@ endif::doctype-manpage[]
 * pname:commandBuffer must: be a primary sname:VkCommandBuffer
 * pname:commandBufferCount must: be greater than `0`
 * Both of pname:commandBuffer, and the elements of pname:pCommandBuffers must: have been created, allocated, or retrieved from the same sname:VkDevice
-* pname:commandBuffer must: have been created with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_PRIMARY
+* pname:commandBuffer must: have been allocated with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_PRIMARY
-* Any given element of pname:pCommandBuffers must: have been created with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY
+* Any given element of pname:pCommandBuffers must: have been allocated with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY
-* Any given element of pname:pCommandBuffers mustnot: be already pending execution in pname:commandBuffer, or appear twice in pname:pCommandBuffers, unless it was created with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
+* Any given element of pname:pCommandBuffers mustnot: be already pending execution in pname:commandBuffer, or appear twice in pname:pCommandBuffers, unless it was recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
-* Any given element of pname:pCommandBuffers mustnot: be already pending execution in any other sname:VkCommandBuffer, unless it was created with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
+* Any given element of pname:pCommandBuffers mustnot: be already pending execution in any other sname:VkCommandBuffer, unless it was recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
 * Any given element of pname:pCommandBuffers must: be in the executable state
 * Any given element of pname:pCommandBuffers must: have been allocated from a sname:VkCommandPool that was created for the same queue family as the sname:VkCommandPool from which pname:commandBuffer was allocated
 * If fname:vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must: have been begun with the pname:contents parameter of fname:vkCmdBeginRenderPass set to ename:VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
@@ -25,6 +25,7 @@ endif::doctype-manpage[]
 * If fname:vkCmdExecuteCommands is being called within a render pass instance, any given element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferInheritanceInfo::pname:subpass set to the index of the subpass which the given command buffer will be executed in
 * If fname:vkCmdExecuteCommands is being called within a render pass instance, any given element of pname:pCommandBuffers must: have been recorded with a render pass that is compatible with the current render pass - see <<renderpass-compatibility>>
 * If fname:vkCmdExecuteCommands is being called within a render pass instance, and any given element of pname:pCommandBuffers was recorded with sname:VkCommandBufferInheritanceInfo::pname:framebuffer not equal to dlink:VK_NULL_HANDLE, that sname:VkFramebuffer must: match the sname:VkFramebuffer used in the current render pass instance
+* If fname:vkCmdExecuteCommands is not being called within a render pass instance, any given element of pname:pCommandBuffers mustnot: have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
 * If the <<features-features-inheritedQueries,inherited queries>> feature is not enabled, pname:commandBuffer mustnot: have any queries <<queries-operation-active,active>>
 * If pname:commandBuffer has a ename:VK_QUERY_TYPE_OCCLUSION query <<queries-operation-active,active>>, then each element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferInheritanceInfo::pname:occlusionQueryEnable set to ename:VK_TRUE
 * If pname:commandBuffer has a ename:VK_QUERY_TYPE_OCCLUSION query <<queries-operation-active,active>>, then each element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferInheritanceInfo::pname:queryFlags having all bits set that are set for the query

doc/specs/vulkan/validity/structs/VkImageCreateInfo.txt

@@ -24,6 +24,7 @@ endif::doctype-manpage[]
 * The pname:width, pname:height, and pname:depth members of pname:extent must: all be greater than `0`
 * pname:mipLevels must: be greater than `0`
 * pname:arrayLayers must: be greater than `0`
+* If pname:flags contains ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, pname:imageType must be ename:VK_IMAGE_TYPE_2D
 * If pname:imageType is ename:VK_IMAGE_TYPE_1D, pname:extent.width must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxImageDimension1D, or sname:VkImageFormatProperties::pname:maxExtent.width (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with pname:format, pname:type, pname:tiling, pname:usage, and pname:flags equal to those in this structure) - whichever is higher
 * If pname:imageType is ename:VK_IMAGE_TYPE_2D and pname:flags does not contain ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, pname:extent.width and pname:extent.height must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxImageDimension2D, or sname:VkImageFormatProperties::pname:maxExtent.width/height (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with pname:format, pname:type, pname:tiling, pname:usage, and pname:flags equal to those in this structure) - whichever is higher
 * If pname:imageType is ename:VK_IMAGE_TYPE_2D and pname:flags contains ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, pname:extent.width and pname:extent.height must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxImageDimensionCube, or sname:VkImageFormatProperties::pname:maxExtent.width/height (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with pname:format, pname:type, pname:tiling, pname:usage, and pname:flags equal to those in this structure) - whichever is higher

doc/specs/vulkan/validity/structs/VkSubmitInfo.txt

@@ -19,11 +19,11 @@ endif::doctype-manpage[]
 * Any given element of pname:pCommandBuffers must: either have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, or not currently be executing on the device
 * Any given element of pname:pCommandBuffers must: be in the executable state
 * If any given element of pname:pCommandBuffers contains commands that execute secondary command buffers, those secondary command buffers must: have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, or not currently be executing on the device
-* If any given element of pname:pCommandBuffers was created with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, it mustnot: have been previously submitted without re-recording that command buffer
+* If any given element of pname:pCommandBuffers was recorded with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, it mustnot: have been previously submitted without re-recording that command buffer
-* If any given element of pname:pCommandBuffers contains commands that execute secondary command buffers created with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, each such secondary command buffer mustnot: have been previously submitted without re-recording that command buffer
+* If any given element of pname:pCommandBuffers contains commands that execute secondary command buffers recorded with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, each such secondary command buffer mustnot: have been previously submitted without re-recording that command buffer
 * Any given element of pname:pCommandBuffers mustnot: contain commands that execute a secondary command buffer, if that secondary command buffer has been recorded in another primary command buffer after it was recorded into this sname:VkCommandBuffer
-* Any given element of pname:pCommandBuffers must: have been created on a sname:VkCommandPool that was created for the same queue family that the calling command's pname:queue belongs to
+* Any given element of pname:pCommandBuffers must: have been allocated from a sname:VkCommandPool that was created for the same queue family that the calling command's pname:queue belongs to
-* Any given element of pname:pCommandBuffers mustnot: have been created with ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY
+* Any given element of pname:pCommandBuffers mustnot: have been allocated with ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY
 * Any given element of sname:VkSemaphore in pname:pWaitSemaphores must: refer to a prior signal of that sname:VkSemaphore that will not be consumed by any other wait on that semaphore
 * If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, any given element of pname:pWaitDstStageMask mustnot: contain ename:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
 * If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, any given element of pname:pWaitDstStageMask mustnot: contain ename:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or ename:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT

doc/specs/vulkan/validity/structs/VkWriteDescriptorSet.txt

@@ -19,14 +19,14 @@ endif::doctype-manpage[]
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pname:pImageInfo must: be a pointer to an array of pname:descriptorCount valid sname:VkDescriptorImageInfo structures
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pname:pTexelBufferView must: be a pointer to an array of pname:descriptorCount valid sname:VkBufferView handles
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pname:pBufferInfo must: be a pointer to an array of pname:descriptorCount valid sname:VkDescriptorBufferInfo structures
-* If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER or ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and pname:dstSet was not created with a layout that included immutable samplers for pname:dstBinding with pname:descriptorType, the pname:sampler member of any given element of pname:pImageInfo must: be a valid sname:VkSampler object
+* If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER or ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and pname:dstSet was not allocated with a layout that included immutable samplers for pname:dstBinding with pname:descriptorType, the pname:sampler member of any given element of pname:pImageInfo must: be a valid sname:VkSampler object
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the pname:imageView and pname:imageLayout members of any given element of pname:pImageInfo must: be a valid sname:VkImageView and elink:VkImageLayout, respectively
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:offset member of any given element of pname:pBufferInfo must: be a multiple of sname:VkPhysicalDeviceLimits::pname:minUniformBufferOffsetAlignment
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:offset member of any given element of pname:pBufferInfo must: be a multiple of sname:VkPhysicalDeviceLimits::pname:minStorageBufferOffsetAlignment
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:buffer member of any given element of pname:pBufferInfo must: have been created with ename:VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:buffer member of any given element of pname:pBufferInfo must: have been created with ename:VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set
-* If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxUniformBufferRange
+* If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo, or the effective range if pname:range is ename:VK_WHOLE_SIZE, must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxUniformBufferRange
-* If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxStorageBufferRange
+* If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo, or the effective range if pname:range is ename:VK_WHOLE_SIZE, must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxStorageBufferRange
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the sname:VkBuffer that any given element of pname:pTexelBufferView was created from must: have been created with ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the sname:VkBuffer that any given element of pname:pTexelBufferView was created from must: have been created with ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set
 * If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the pname:imageView member of any given element of pname:pImageInfo must: have been created with the identity swizzle

src/spec/vk.xml

@@ -101,7 +101,7 @@ maintained in the master branch of the Khronos Vulkan Github project.
         <type category="define">// Vulkan 1.0 version number
 #define <name>VK_API_VERSION_1_0</name> <type>VK_MAKE_VERSION</type>(1, 0, 0)</type>    <!-- The patch version here should never be set to anything other than 0 -->
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 23</type>
+#define <name>VK_HEADER_VERSION</name> 24</type>
 
         <type category="define">
 #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
@@ -626,14 +626,14 @@ maintained in the master branch of the Khronos Vulkan Github project.
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pname:pImageInfo must: be a pointer to an array of pname:descriptorCount valid sname:VkDescriptorImageInfo structures</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pname:pTexelBufferView must: be a pointer to an array of pname:descriptorCount valid sname:VkBufferView handles</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pname:pBufferInfo must: be a pointer to an array of pname:descriptorCount valid sname:VkDescriptorBufferInfo structures</usage>
-                <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER or ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and pname:dstSet was not created with a layout that included immutable samplers for pname:dstBinding with pname:descriptorType, the pname:sampler member of any given element of pname:pImageInfo must: be a valid sname:VkSampler object</usage>
+                <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER or ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and pname:dstSet was not allocated with a layout that included immutable samplers for pname:dstBinding with pname:descriptorType, the pname:sampler member of any given element of pname:pImageInfo must: be a valid sname:VkSampler object</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the pname:imageView and pname:imageLayout members of any given element of pname:pImageInfo must: be a valid sname:VkImageView and elink:VkImageLayout, respectively</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:offset member of any given element of pname:pBufferInfo must: be a multiple of sname:VkPhysicalDeviceLimits::pname:minUniformBufferOffsetAlignment</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:offset member of any given element of pname:pBufferInfo must: be a multiple of sname:VkPhysicalDeviceLimits::pname:minStorageBufferOffsetAlignment</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:buffer member of any given element of pname:pBufferInfo must: have been created with ename:VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:buffer member of any given element of pname:pBufferInfo must: have been created with ename:VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set</usage>
-                <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxUniformBufferRange</usage>
+                <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo, or the effective range if pname:range is ename:VK_WHOLE_SIZE, must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxUniformBufferRange</usage>
-                <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxStorageBufferRange</usage>
+                <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo, or the effective range if pname:range is ename:VK_WHOLE_SIZE, must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxStorageBufferRange</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the sname:VkBuffer that any given element of pname:pTexelBufferView was created from must: have been created with ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the sname:VkBuffer that any given element of pname:pTexelBufferView was created from must: have been created with ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set</usage>
                 <usage>If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the pname:imageView member of any given element of pname:pImageInfo must: have been created with the identity swizzle</usage>
@@ -804,6 +804,7 @@ maintained in the master branch of the Khronos Vulkan Github project.
                 <usage>The pname:width, pname:height, and pname:depth members of pname:extent must: all be greater than `0`</usage>
                 <usage>pname:mipLevels must: be greater than `0`</usage>
                 <usage>pname:arrayLayers must: be greater than `0`</usage>
+                <usage>If pname:flags contains ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, pname:imageType must be ename:VK_IMAGE_TYPE_2D</usage>
                 <usage>If pname:imageType is ename:VK_IMAGE_TYPE_1D, pname:extent.width must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxImageDimension1D, or sname:VkImageFormatProperties::pname:maxExtent.width (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with pname:format, pname:type, pname:tiling, pname:usage, and pname:flags equal to those in this structure) - whichever is higher</usage>
                 <usage>If pname:imageType is ename:VK_IMAGE_TYPE_2D and pname:flags does not contain ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, pname:extent.width and pname:extent.height must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxImageDimension2D, or sname:VkImageFormatProperties::pname:maxExtent.width/height (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with pname:format, pname:type, pname:tiling, pname:usage, and pname:flags equal to those in this structure) - whichever is higher</usage>
                 <usage>If pname:imageType is ename:VK_IMAGE_TYPE_2D and pname:flags contains ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, pname:extent.width and pname:extent.height must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxImageDimensionCube, or sname:VkImageFormatProperties::pname:maxExtent.width/height (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with pname:format, pname:type, pname:tiling, pname:usage, and pname:flags equal to those in this structure) - whichever is higher</usage>
@@ -1938,11 +1939,11 @@ maintained in the master branch of the Khronos Vulkan Github project.
                 <usage>Any given element of pname:pCommandBuffers must: either have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, or not currently be executing on the device</usage>
                 <usage>Any given element of pname:pCommandBuffers must: be in the executable state</usage>
                 <usage>If any given element of pname:pCommandBuffers contains commands that execute secondary command buffers, those secondary command buffers must: have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, or not currently be executing on the device</usage>
-                <usage>If any given element of pname:pCommandBuffers was created with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, it mustnot: have been previously submitted without re-recording that command buffer</usage>
+                <usage>If any given element of pname:pCommandBuffers was recorded with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, it mustnot: have been previously submitted without re-recording that command buffer</usage>
-                <usage>If any given element of pname:pCommandBuffers contains commands that execute secondary command buffers created with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, each such secondary command buffer mustnot: have been previously submitted without re-recording that command buffer</usage>
+                <usage>If any given element of pname:pCommandBuffers contains commands that execute secondary command buffers recorded with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, each such secondary command buffer mustnot: have been previously submitted without re-recording that command buffer</usage>
                 <usage>Any given element of pname:pCommandBuffers mustnot: contain commands that execute a secondary command buffer, if that secondary command buffer has been recorded in another primary command buffer after it was recorded into this sname:VkCommandBuffer</usage>
-                <usage>Any given element of pname:pCommandBuffers must: have been created on a sname:VkCommandPool that was created for the same queue family that the calling command's pname:queue belongs to</usage>
+                <usage>Any given element of pname:pCommandBuffers must: have been allocated from a sname:VkCommandPool that was created for the same queue family that the calling command's pname:queue belongs to</usage>
-                <usage>Any given element of pname:pCommandBuffers mustnot: have been created with ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY</usage>
+                <usage>Any given element of pname:pCommandBuffers mustnot: have been allocated with ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY</usage>
                 <usage>Any given element of sname:VkSemaphore in pname:pWaitSemaphores must: refer to a prior signal of that sname:VkSemaphore that will not be consumed by any other wait on that semaphore</usage>
                 <usage>If the &lt;&lt;features-features-geometryShader,geometry shaders&gt;&gt; feature is not enabled, any given element of pname:pWaitDstStageMask mustnot: contain ename:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT</usage>
                 <usage>If the &lt;&lt;features-features-tessellationShader,tessellation shaders&gt;&gt; feature is not enabled, any given element of pname:pWaitDstStageMask mustnot: contain ename:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or ename:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</usage>
@@ -3945,7 +3946,7 @@ maintained in the master branch of the Khronos Vulkan Github project.
             <param optional="true"><type>uint32_t</type> <name>dynamicOffsetCount</name></param>
             <param len="dynamicOffsetCount">const <type>uint32_t</type>* <name>pDynamicOffsets</name></param>
             <validity>
-                <usage>Any given element of pname:pDescriptorSets must: have been created with a sname:VkDescriptorSetLayout that matches (is the same as, or defined identically to) the sname:VkDescriptorSetLayout at set _n_ in pname:layout, where _n_ is the sum of pname:firstSet and the index into pname:pDescriptorSets</usage>
+                <usage>Any given element of pname:pDescriptorSets must: have been allocated with a sname:VkDescriptorSetLayout that matches (is the same as, or defined identically to) the sname:VkDescriptorSetLayout at set _n_ in pname:layout, where _n_ is the sum of pname:firstSet and the index into pname:pDescriptorSets</usage>
                 <usage>pname:dynamicOffsetCount must: be equal to the total number of dynamic descriptors in pname:pDescriptorSets</usage>
                 <usage>The sum of pname:firstSet and pname:descriptorSetCount must: be less than or equal to sname:VkPipelineLayoutCreateInfo::pname:setLayoutCount provided when pname:layout was created</usage>
                 <usage>pname:pipelineBindPoint must: be supported by the pname:commandBuffer's parent sname:VkCommandPool's queue family</usage>
@@ -4428,9 +4429,9 @@ maintained in the master branch of the Khronos Vulkan Github project.
                 <usage>If the &lt;&lt;features-features-occlusionQueryPrecise,precise occlusion queries&gt;&gt; feature is not enabled, or the pname:queryType used to create pname:queryPool was not ename:VK_QUERY_TYPE_OCCLUSION, pname:flags mustnot: contain ename:VK_QUERY_CONTROL_PRECISE_BIT</usage>
                 <usage>pname:queryPool must: have been created with a pname:queryType that differs from that of any other queries that have been made &lt;&lt;queries-operation-active,active&gt;&gt;, and are currently still active within pname:commandBuffer</usage>
                 <usage>pname:query must: be less than the number of queries in pname:queryPool</usage>
-                <usage>If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_OCCLUSION, the sname:VkCommandPool that pname:commandBuffer was created from must: support graphics operations</usage>
+                <usage>If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_OCCLUSION, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support graphics operations</usage>
-                <usage>If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate graphics operations, the sname:VkCommandPool that pname:commandBuffer was created from must: support graphics operations</usage>
+                <usage>If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate graphics operations, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support graphics operations</usage>
-                <usage>If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate compute operations, the sname:VkCommandPool that pname:commandBuffer was created from must: support compute operations</usage>
+                <usage>If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate compute operations, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support compute operations</usage>
             </validity>
         </command>
         <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
@@ -4537,10 +4538,10 @@ maintained in the master branch of the Khronos Vulkan Github project.
             <param><type>uint32_t</type> <name>commandBufferCount</name></param>
             <param len="commandBufferCount">const <type>VkCommandBuffer</type>* <name>pCommandBuffers</name></param>
             <validity>
-                <usage>pname:commandBuffer must: have been created with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_PRIMARY</usage>
+                <usage>pname:commandBuffer must: have been allocated with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_PRIMARY</usage>
-                <usage>Any given element of pname:pCommandBuffers must: have been created with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY</usage>
+                <usage>Any given element of pname:pCommandBuffers must: have been allocated with a pname:level of ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY</usage>
-                <usage>Any given element of pname:pCommandBuffers mustnot: be already pending execution in pname:commandBuffer, or appear twice in pname:pCommandBuffers, unless it was created with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag</usage>
+                <usage>Any given element of pname:pCommandBuffers mustnot: be already pending execution in pname:commandBuffer, or appear twice in pname:pCommandBuffers, unless it was recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag</usage>
-                <usage>Any given element of pname:pCommandBuffers mustnot: be already pending execution in any other sname:VkCommandBuffer, unless it was created with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag</usage>
+                <usage>Any given element of pname:pCommandBuffers mustnot: be already pending execution in any other sname:VkCommandBuffer, unless it was recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag</usage>
                 <usage>Any given element of pname:pCommandBuffers must: be in the executable state</usage>
                 <usage>Any given element of pname:pCommandBuffers must: have been allocated from a sname:VkCommandPool that was created for the same queue family as the sname:VkCommandPool from which pname:commandBuffer was allocated</usage>
                 <usage>If fname:vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must: have been begun with the pname:contents parameter of fname:vkCmdBeginRenderPass set to ename:VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS</usage>
@@ -4548,6 +4549,7 @@ maintained in the master branch of the Khronos Vulkan Github project.
                 <usage>If fname:vkCmdExecuteCommands is being called within a render pass instance, any given element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferInheritanceInfo::pname:subpass set to the index of the subpass which the given command buffer will be executed in</usage>
                 <usage>If fname:vkCmdExecuteCommands is being called within a render pass instance, any given element of pname:pCommandBuffers must: have been recorded with a render pass that is compatible with the current render pass - see &lt;&lt;renderpass-compatibility&gt;&gt;</usage>
                 <usage>If fname:vkCmdExecuteCommands is being called within a render pass instance, and any given element of pname:pCommandBuffers was recorded with sname:VkCommandBufferInheritanceInfo::pname:framebuffer not equal to dlink:VK_NULL_HANDLE, that sname:VkFramebuffer must: match the sname:VkFramebuffer used in the current render pass instance</usage>
+                <usage>If fname:vkCmdExecuteCommands is not being called within a render pass instance, any given element of pname:pCommandBuffers mustnot: have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT</usage>
                 <usage>If the &lt;&lt;features-features-inheritedQueries,inherited queries&gt;&gt; feature is not enabled, pname:commandBuffer mustnot: have any queries &lt;&lt;queries-operation-active,active&gt;&gt;</usage>
                 <usage>If pname:commandBuffer has a ename:VK_QUERY_TYPE_OCCLUSION query &lt;&lt;queries-operation-active,active&gt;&gt;, then each element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferInheritanceInfo::pname:occlusionQueryEnable set to ename:VK_TRUE</usage>
                 <usage>If pname:commandBuffer has a ename:VK_QUERY_TYPE_OCCLUSION query &lt;&lt;queries-operation-active,active&gt;&gt;, then each element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferInheritanceInfo::pname:queryFlags having all bits set that are set for the query</usage>
@@ -5542,5 +5544,19 @@ maintained in the master branch of the Khronos Vulkan Github project.
                 <enum value="&quot;VK_NV_extension_54&quot;"            name="VK_NV_EXTENSION_54_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_IMG_format_pvrtc" number="55" author="IMG" contact="Tobias Hector @tobias" supported="vulkan">
+            <require>
+                <enum value="1"                                         name="VK_IMG_FORMAT_PVRTC_SPEC_VERSION"/>
+                <enum value="&quot;VK_IMG_format_pvrtc&quot;"           name="VK_IMG_FORMAT_PVRTC_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkFormat"                     name="VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"/>
+                <enum offset="1" extends="VkFormat"                     name="VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"/>
+                <enum offset="2" extends="VkFormat"                     name="VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"/>
+                <enum offset="3" extends="VkFormat"                     name="VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"/>
+                <enum offset="4" extends="VkFormat"                     name="VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"/>
+                <enum offset="5" extends="VkFormat"                     name="VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"/>
+                <enum offset="6" extends="VkFormat"                     name="VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"/>
+                <enum offset="7" extends="VkFormat"                     name="VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"/>
+            </require>
+        </extension>
     </extensions>
 </registry>

src/vulkan/vulkan.h

@@ -43,7 +43,7 @@ extern "C" {
 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
 // Version of this file
-#define VK_HEADER_VERSION 23
+#define VK_HEADER_VERSION 24
 
 
 #define VK_NULL_HANDLE 0
@@ -430,6 +430,14 @@ typedef enum VkFormat {
     VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
     VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
     VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
+    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
+    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
+    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
+    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
+    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
+    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
+    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
     VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
     VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
     VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
@@ -3956,6 +3964,11 @@ typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
 
 
 
+#define VK_IMG_format_pvrtc 1
+#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
+#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
+
+
 #ifdef __cplusplus
 }
 #endif