| // Copyright 2015-2021 The Khronos Group, Inc. |
| // |
| // SPDX-License-Identifier: CC-BY-4.0 |
| |
| [[primsrast]] |
| = Rasterization |
| |
| Rasterization is the process by which a primitive is converted to a |
| two-dimensional image. |
| Each discrete location of this image contains associated data such as depth, |
| color, or other attributes. |
| |
| Rasterizing a primitive begins by determining which squares of an integer |
| grid in framebuffer coordinates are occupied by the primitive, and assigning |
| one or more depth values to each such square. |
| This process is described below for points, lines, and polygons. |
| |
| A grid square, including its [eq]#(x,y)# framebuffer coordinates, [eq]#z# |
| (depth), and associated data added by fragment shaders, is called a |
| fragment. |
| A fragment is located by its upper left corner, which lies on integer grid |
| coordinates. |
| |
| Rasterization operations also refer to a fragment's sample locations, which |
| are offset by fractional values from its upper left corner. |
| The rasterization rules for points, lines, and triangles involve testing |
| whether each sample location is inside the primitive. |
| Fragments need not actually be square, and rasterization rules are not |
| affected by the aspect ratio of fragments. |
| Display of non-square grids, however, will cause rasterized points and line |
| segments to appear fatter in one direction than the other. |
| |
| We assume that fragments are square, since it simplifies antialiasing and |
| texturing. |
| After rasterization, fragments are processed by <<fragops, fragment |
| operations>>. |
| |
| Several factors affect rasterization, including the members of |
| slink:VkPipelineRasterizationStateCreateInfo and |
| slink:VkPipelineMultisampleStateCreateInfo. |
| |
| [open,refpage='VkPipelineRasterizationStateCreateInfo',desc='Structure specifying parameters of a newly created pipeline rasterization state',type='structs'] |
| -- |
| The sname:VkPipelineRasterizationStateCreateInfo structure is defined as: |
| |
| include::{generated}/api/structs/VkPipelineRasterizationStateCreateInfo.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:flags is reserved for future use. |
| * pname:depthClampEnable controls whether to clamp the fragment's depth |
| values as described in <<fragops-depth,Depth Test>>. |
| ifdef::VK_EXT_depth_clip_enable[] |
| If the pipeline is not created with |
| slink:VkPipelineRasterizationDepthClipStateCreateInfoEXT present then |
| enabling depth clamp will also disable clipping primitives to the z |
| planes of the frustrum as described in <<vertexpostproc-clipping, |
| Primitive Clipping>>. |
| Otherwise depth clipping is controlled by the state set in |
| slink:VkPipelineRasterizationDepthClipStateCreateInfoEXT. |
| endif::VK_EXT_depth_clip_enable[] |
| ifndef::VK_EXT_depth_clip_enable[] |
| Enabling depth clamp will also disable clipping primitives to the z |
| planes of the frustrum as described in <<vertexpostproc-clipping, |
| Primitive Clipping>>. |
| endif::VK_EXT_depth_clip_enable[] |
| * pname:rasterizerDiscardEnable controls whether primitives are discarded |
| immediately before the rasterization stage. |
| * pname:polygonMode is the triangle rendering mode. |
| See elink:VkPolygonMode. |
| * pname:cullMode is the triangle facing direction used for primitive |
| culling. |
| See elink:VkCullModeFlagBits. |
| * pname:frontFace is a elink:VkFrontFace value specifying the front-facing |
| triangle orientation to be used for culling. |
| * pname:depthBiasEnable controls whether to bias fragment depth values. |
| * pname:depthBiasConstantFactor is a scalar factor controlling the |
| constant depth value added to each fragment. |
| * pname:depthBiasClamp is the maximum (or minimum) depth bias of a |
| fragment. |
| * pname:depthBiasSlopeFactor is a scalar factor applied to a fragment's |
| slope in depth bias calculations. |
| * pname:lineWidth is the width of rasterized line segments. |
| |
| ifdef::VK_AMD_rasterization_order[] |
| The application can: also add a |
| sname:VkPipelineRasterizationStateRasterizationOrderAMD structure to the |
| pname:pNext chain of a slink:VkPipelineRasterizationStateCreateInfo |
| structure. |
| This structure enables selecting the rasterization order to use when |
| rendering with the corresponding graphics pipeline as described in |
| <<primsrast-order, Rasterization Order>>. |
| endif::VK_AMD_rasterization_order[] |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782]] |
| If the <<features-depthClamp,depth clamping>> feature is not enabled, |
| pname:depthClampEnable must: be ename:VK_FALSE |
| ifndef::VK_NV_fill_rectangle[] |
| * [[VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413]] |
| If the <<features-fillModeNonSolid,non-solid fill modes>> feature is not |
| enabled, pname:polygonMode must: be ename:VK_POLYGON_MODE_FILL |
| endif::VK_NV_fill_rectangle[] |
| ifdef::VK_NV_fill_rectangle[] |
| * [[VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507]] |
| If the <<features-fillModeNonSolid,non-solid fill modes>> feature is not |
| enabled, pname:polygonMode must: be ename:VK_POLYGON_MODE_FILL or |
| ename:VK_POLYGON_MODE_FILL_RECTANGLE_NV |
| * [[VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414]] |
| If the `apiext:VK_NV_fill_rectangle` extension is not enabled, |
| pname:polygonMode must: not be ename:VK_POLYGON_MODE_FILL_RECTANGLE_NV |
| endif::VK_NV_fill_rectangle[] |
| ifdef::VK_KHR_portability_subset[] |
| * [[VUID-VkPipelineRasterizationStateCreateInfo-pointPolygons-04458]] |
| If the `apiext:VK_KHR_portability_subset` extension is enabled, and |
| slink:VkPhysicalDevicePortabilitySubsetFeaturesKHR::pname:pointPolygons |
| is ename:VK_FALSE, and pname:rasterizerDiscardEnable is ename:VK_FALSE, |
| pname:polygonMode must: not be ename:VK_POLYGON_MODE_POINT |
| endif::VK_KHR_portability_subset[] |
| **** |
| |
| include::{generated}/validity/structs/VkPipelineRasterizationStateCreateInfo.txt[] |
| -- |
| |
| [open,refpage='VkPipelineRasterizationStateCreateFlags',desc='Reserved for future use',type='flags'] |
| -- |
| include::{generated}/api/flags/VkPipelineRasterizationStateCreateFlags.txt[] |
| |
| tname:VkPipelineRasterizationStateCreateFlags is a bitmask type for setting |
| a mask, but is currently reserved for future use. |
| -- |
| |
| ifdef::VK_EXT_depth_clip_enable[] |
| [open,refpage='VkPipelineRasterizationDepthClipStateCreateInfoEXT',desc='Structure specifying depth clipping state',type='structs'] |
| -- |
| If the pname:pNext chain of slink:VkPipelineRasterizationStateCreateInfo |
| includes a sname:VkPipelineRasterizationDepthClipStateCreateInfoEXT |
| structure, then that structure controls whether depth clipping is enabled or |
| disabled. |
| |
| The sname:VkPipelineRasterizationDepthClipStateCreateInfoEXT structure is |
| defined as: |
| |
| include::{generated}/api/structs/VkPipelineRasterizationDepthClipStateCreateInfoEXT.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:flags is reserved for future use. |
| * pname:depthClipEnable controls whether depth clipping is enabled as |
| described in <<vertexpostproc-clipping, Primitive Clipping>>. |
| |
| include::{generated}/validity/structs/VkPipelineRasterizationDepthClipStateCreateInfoEXT.txt[] |
| -- |
| |
| [open,refpage='VkPipelineRasterizationDepthClipStateCreateFlagsEXT',desc='Reserved for future use',type='flags'] |
| -- |
| include::{generated}/api/flags/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.txt[] |
| |
| tname:VkPipelineRasterizationDepthClipStateCreateFlagsEXT is a bitmask type |
| for setting a mask, but is currently reserved for future use. |
| -- |
| endif::VK_EXT_depth_clip_enable[] |
| |
| [open,refpage='VkPipelineMultisampleStateCreateInfo',desc='Structure specifying parameters of a newly created pipeline multisample state',type='structs'] |
| -- |
| The sname:VkPipelineMultisampleStateCreateInfo structure is defined as: |
| |
| include::{generated}/api/structs/VkPipelineMultisampleStateCreateInfo.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:flags is reserved for future use. |
| * pname:rasterizationSamples is a elink:VkSampleCountFlagBits value |
| specifying the number of samples used in rasterization. |
| * pname:sampleShadingEnable can: be used to enable |
| <<primsrast-sampleshading,Sample Shading>>. |
| * pname:minSampleShading specifies a minimum fraction of sample shading if |
| pname:sampleShadingEnable is set to ename:VK_TRUE. |
| * pname:pSampleMask is a pointer to an array of basetype:VkSampleMask |
| values used in the <<fragops-samplemask,sample mask test>>. |
| * pname:alphaToCoverageEnable controls whether a temporary coverage value |
| is generated based on the alpha component of the fragment's first color |
| output as specified in the <<fragops-covg,Multisample Coverage>> |
| section. |
| * pname:alphaToOneEnable controls whether the alpha component of the |
| fragment's first color output is replaced with one as described in |
| <<fragops-covg,Multisample Coverage>>. |
| |
| Each bit in the sample mask is associated with a unique |
| <<primsrast-multisampling-coverage-mask, sample index>> as defined for the |
| <<primsrast-multisampling-coverage-mask, coverage mask>>. |
| Each bit [eq]#b# for mask word [eq]#w# in the sample mask corresponds to |
| sample index [eq]#i#, where [eq]#i = 32 {times} w {plus} b#. |
| pname:pSampleMask has a length equal to [eq]#{lceil} |
| pname:rasterizationSamples / 32 {rceil}# words. |
| |
| If pname:pSampleMask is `NULL`, it is treated as if the mask has all bits |
| set to `1`. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784]] |
| If the <<features-sampleRateShading,sample rate shading>> feature is not |
| enabled, pname:sampleShadingEnable must: be ename:VK_FALSE |
| * [[VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785]] |
| If the <<features-alphaToOne,alpha to one>> feature is not enabled, |
| pname:alphaToOneEnable must: be ename:VK_FALSE |
| * [[VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786]] |
| pname:minSampleShading must: be in the range [eq]#[0,1]# |
| ifdef::VK_NV_framebuffer_mixed_samples[] |
| * [[VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415]] |
| If the `apiext:VK_NV_framebuffer_mixed_samples` extension is enabled, |
| and if the subpass has any color attachments and |
| pname:rasterizationSamples is greater than the number of color samples, |
| then pname:sampleShadingEnable must: be ename:VK_FALSE |
| endif::VK_NV_framebuffer_mixed_samples[] |
| **** |
| |
| include::{generated}/validity/structs/VkPipelineMultisampleStateCreateInfo.txt[] |
| -- |
| |
| [open,refpage='VkPipelineMultisampleStateCreateFlags',desc='Reserved for future use',type='flags'] |
| -- |
| include::{generated}/api/flags/VkPipelineMultisampleStateCreateFlags.txt[] |
| |
| tname:VkPipelineMultisampleStateCreateFlags is a bitmask type for setting a |
| mask, but is currently reserved for future use. |
| -- |
| |
| [open,refpage='VkSampleMask',desc='Mask of sample coverage information',type='basetypes',xrefs='VkPipelineMultisampleStateCreateInfo'] |
| -- |
| The elements of the sample mask array are of type basetype:VkSampleMask, |
| each representing 32 bits of coverage information: |
| |
| include::{generated}/api/basetypes/VkSampleMask.txt[] |
| -- |
| |
| Rasterization only generates fragments which cover one or more pixels inside |
| the framebuffer. |
| Pixels outside the framebuffer are never considered covered in the fragment. |
| Fragments which would be produced by application of any of the primitive |
| rasterization rules described below but which lie outside the framebuffer |
| are not produced, nor are they processed by any later stage of the pipeline, |
| including any of the <<fragops, fragment operations>>. |
| |
| Surviving fragments are processed by fragment shaders. |
| Fragment shaders determine associated data for fragments, and can: also |
| modify or replace their assigned depth values. |
| |
| |
| [[primsrast-discard]] |
| == Discarding Primitives Before Rasterization |
| |
| Primitives are discarded before rasterization if the |
| pname:rasterizerDiscardEnable member of |
| slink:VkPipelineRasterizationStateCreateInfo is enabled. |
| When enabled, primitives are discarded after they are processed by the last |
| active shader stage in the pipeline before rasterization. |
| |
| ifdef::VK_EXT_extended_dynamic_state2[] |
| [open,refpage='vkCmdSetRasterizerDiscardEnableEXT',desc='Control whether primitives are discarded before the rasterization stage dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically enable>> whether primitives are |
| discarded before the rasterization stage, call: |
| |
| include::{generated}/api/protos/vkCmdSetRasterizerDiscardEnableEXT.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:rasterizerDiscardEnable controls whether primitives are discarded |
| immediately before the rasterization stage. |
| |
| This command sets the discard enable for subsequent drawing commands when |
| the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineRasterizationStateCreateInfo::pname:rasterizerDiscardEnable |
| value used to create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetRasterizerDiscardEnableEXT-None-04871]] |
| The <<features-extendedDynamicState2, extendedDynamicState2>> feature |
| must: be enabled |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetRasterizerDiscardEnableEXT.txt[] |
| -- |
| endif::VK_EXT_extended_dynamic_state2[] |
| |
| |
| ifdef::VK_EXT_transform_feedback[] |
| [[primsrast-stream]] |
| == Controlling the Vertex Stream Used for Rasterization |
| |
| By default vertex data output from the last |
| <<pipeline-graphics-subsets-pre-rasterization,pre-rasterization shader |
| stage>> are directed to vertex stream zero. |
| Geometry shaders can: emit primitives to multiple independent vertex |
| streams. |
| Each vertex emitted by the geometry shader is directed at one of the vertex |
| streams. |
| As vertices are received on each vertex stream, they are arranged into |
| primitives of the type specified by the geometry shader output primitive |
| type. |
| The shading language instructions code:OpEndPrimitive and |
| code:OpEndStreamPrimitive can: be used to end the primitive being assembled |
| on a given vertex stream and start a new empty primitive of the same type. |
| An implementation supports up to |
| sname:VkPhysicalDeviceTransformFeedbackPropertiesEXT::pname:maxTransformFeedbackStreams |
| streams, which is at least 1. |
| The individual streams are numbered 0 through |
| pname:maxTransformFeedbackStreams minus 1. |
| There is no requirement on the order of the streams to which vertices are |
| emitted, and the number of vertices emitted to each vertex stream can: be |
| completely independent, subject only to the |
| sname:VkPhysicalDeviceTransformFeedbackPropertiesEXT::pname:maxTransformFeedbackStreamDataSize |
| and |
| sname:VkPhysicalDeviceTransformFeedbackPropertiesEXT::pname:maxTransformFeedbackBufferDataSize |
| limits. |
| The primitives output from all vertex streams are passed to the transform |
| feedback stage to be captured to transform feedback buffers in the manner |
| specified by the last |
| <<pipeline-graphics-subsets-pre-rasterization,pre-rasterization shader |
| stage>> shader's code:XfbBuffer, code:XfbStride, and code:Offsets |
| decorations on the output interface variables in the graphics pipeline. |
| To use a vertex stream other than zero, or to use multiple streams, the |
| code:GeometryStreams capability must: be specified. |
| |
| By default, the primitives output from vertex stream zero are rasterized. |
| If the implementation supports the |
| slink:VkPhysicalDeviceTransformFeedbackPropertiesEXT::pname:transformFeedbackRasterizationStreamSelect |
| property it is possible to rasterize a vertex stream other than zero. |
| |
| By default, geometry shaders that emit vertices to multiple vertex streams |
| are limited to using only the code:OutputPoints output primitive type. |
| If the implementation supports the |
| slink:VkPhysicalDeviceTransformFeedbackPropertiesEXT::pname:transformFeedbackStreamsLinesTriangles |
| property it is possible to emit code:OutputLineStrip or |
| code:OutputTriangleStrip in addition to code:OutputPoints. |
| |
| [open,refpage='VkPipelineRasterizationStateStreamCreateInfoEXT',desc='Structure defining the geometry stream used for rasterization',type='structs'] |
| -- |
| The vertex stream used for rasterization is specified by adding a |
| sname:VkPipelineRasterizationStateStreamCreateInfoEXT structure to the |
| pname:pNext chain of a slink:VkPipelineRasterizationStateCreateInfo |
| structure. |
| |
| The sname:VkPipelineRasterizationStateStreamCreateInfoEXT structure is |
| defined as: |
| |
| include::{generated}/api/structs/VkPipelineRasterizationStateStreamCreateInfoEXT.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:flags is reserved for future use. |
| * pname:rasterizationStream is the vertex stream selected for |
| rasterization. |
| |
| If this structure is not present, pname:rasterizationStream is assumed to be |
| zero. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-geometryStreams-02324]] |
| sname:VkPhysicalDeviceTransformFeedbackFeaturesEXT::pname:geometryStreams |
| must: be enabled |
| * [[VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-rasterizationStream-02325]] |
| pname:rasterizationStream must: be less than |
| slink:VkPhysicalDeviceTransformFeedbackPropertiesEXT::pname:maxTransformFeedbackStreams |
| * [[VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-rasterizationStream-02326]] |
| pname:rasterizationStream must: be zero if |
| sname:VkPhysicalDeviceTransformFeedbackPropertiesEXT::pname:transformFeedbackRasterizationStreamSelect |
| is ename:VK_FALSE |
| **** |
| |
| include::{generated}/validity/structs/VkPipelineRasterizationStateStreamCreateInfoEXT.txt[] |
| -- |
| |
| [open,refpage='VkPipelineRasterizationStateStreamCreateFlagsEXT',desc='Reserved for future use',type='flags'] |
| -- |
| include::{generated}/api/flags/VkPipelineRasterizationStateStreamCreateFlagsEXT.txt[] |
| |
| tname:VkPipelineRasterizationStateStreamCreateFlagsEXT is a bitmask type for |
| setting a mask, but is currently reserved for future use. |
| -- |
| endif::VK_EXT_transform_feedback[] |
| |
| |
| [[primsrast-order]] |
| == Rasterization Order |
| |
| Within a subpass of a <<renderpass,render pass instance>>, for a given |
| (x,y,layer,sample) sample location, the following operations are guaranteed |
| to execute in _rasterization order_, for each separate primitive that |
| includes that sample location: |
| |
| . <<fragops, Fragment operations>>, in the order defined |
| . <<framebuffer-blending, Blending>>, <<framebuffer-logicop, logic |
| operations>>, and color writes |
| |
| Execution of these operations for each primitive in a subpass occurs in |
| ifndef::VK_AMD_rasterization_order[] |
| <<drawing-primitive-order, primitive order>>. |
| endif::VK_AMD_rasterization_order[] |
| ifdef::VK_AMD_rasterization_order[] |
| an order determined by the application. |
| |
| [open,refpage='VkPipelineRasterizationStateRasterizationOrderAMD',desc='Structure defining rasterization order for a graphics pipeline',type='structs'] |
| -- |
| The rasterization order to use for a graphics pipeline is specified by |
| adding a sname:VkPipelineRasterizationStateRasterizationOrderAMD structure |
| to the pname:pNext chain of a slink:VkPipelineRasterizationStateCreateInfo |
| structure. |
| |
| The sname:VkPipelineRasterizationStateRasterizationOrderAMD structure is |
| defined as: |
| |
| include::{generated}/api/structs/VkPipelineRasterizationStateRasterizationOrderAMD.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:rasterizationOrder is a elink:VkRasterizationOrderAMD value |
| specifying the primitive rasterization order to use. |
| |
| include::{generated}/validity/structs/VkPipelineRasterizationStateRasterizationOrderAMD.txt[] |
| |
| If the `apiext:VK_AMD_rasterization_order` device extension is not enabled |
| or the application does not request a particular rasterization order through |
| specifying a sname:VkPipelineRasterizationStateRasterizationOrderAMD |
| structure then the rasterization order used by the graphics pipeline |
| defaults to ename:VK_RASTERIZATION_ORDER_STRICT_AMD. |
| -- |
| |
| [open,refpage='VkRasterizationOrderAMD',desc='Specify rasterization order for a graphics pipeline',type='enums'] |
| -- |
| Possible values of |
| slink:VkPipelineRasterizationStateRasterizationOrderAMD::pname:rasterizationOrder, |
| specifying the primitive rasterization order, are: |
| |
| include::{generated}/api/enums/VkRasterizationOrderAMD.txt[] |
| |
| * ename:VK_RASTERIZATION_ORDER_STRICT_AMD specifies that operations for |
| each primitive in a subpass must: occur in <<drawing-primitive-order, |
| primitive order>>. |
| * ename:VK_RASTERIZATION_ORDER_RELAXED_AMD specifies that operations for |
| each primitive in a subpass may: not occur in <<drawing-primitive-order, |
| primitive order>>. |
| -- |
| endif::VK_AMD_rasterization_order[] |
| |
| |
| [[primsrast-multisampling]] |
| == Multisampling |
| |
| Multisampling is a mechanism to antialias all Vulkan primitives: points, |
| lines, and polygons. |
| The technique is to sample all primitives multiple times at each pixel. |
| Each sample in each framebuffer attachment has storage for a color, depth, |
| and/or stencil value, such that per-fragment operations apply to each sample |
| independently. |
| The color sample values can: be later _resolved_ to a single color (see |
| <<copies-resolve,Resolving Multisample Images>> and the <<renderpass,Render |
| Pass>> chapter for more details on how to resolve multisample images to |
| non-multisample images). |
| |
| Vulkan defines rasterization rules for single-sample modes in a way that is |
| equivalent to a multisample mode with a single sample in the center of each |
| fragment. |
| |
| Each fragment includes a <<primsrast-multisampling-coverage-mask, coverage |
| mask>> with a single bit for each sample in the fragment, and a number of |
| depth values and associated data for each sample. |
| An implementation may: choose to assign the same associated data to more |
| than one sample. |
| The location for evaluating such associated data may: be anywhere within the |
| fragment area including the fragment's center location [eq]#(x~f~,y~f~)# or |
| any of the sample locations. |
| When pname:rasterizationSamples is ename:VK_SAMPLE_COUNT_1_BIT, the |
| fragment's center location must: be used. |
| The different associated data values need not all be evaluated at the same |
| location. |
| |
| It is understood that each pixel has pname:rasterizationSamples locations |
| associated with it. |
| These locations are exact positions, rather than regions or areas, and each |
| is referred to as a sample point. |
| The sample points associated with a pixel must: be located inside or on the |
| boundary of the unit square that is considered to bound the pixel. |
| Furthermore, the relative locations of sample points may: be identical for |
| each pixel in the framebuffer, or they may: differ. |
| |
| ifdef::VK_EXT_fragment_density_map[] |
| If the render pass has a fragment density map attachment, each fragment only |
| has pname:rasterizationSamples locations associated with it regardless of |
| how many pixels are covered in the fragment area. |
| Fragment sample locations are defined as if the fragment had an area of |
| [eq]#(1,1)# and its sample points must: be located within these bounds. |
| Their actual location in the framebuffer is calculated by scaling the sample |
| location by the fragment area. |
| Attachments with storage for multiple samples per pixel are located at the |
| pixel sample locations. |
| Otherwise, the fragment's sample locations are generally used for evaluation |
| of associated data and fragment operations. |
| endif::VK_EXT_fragment_density_map[] |
| |
| If the current pipeline includes a fragment shader with one or more |
| variables in its interface decorated with code:Sample and code:Input, the |
| data associated with those variables will be assigned independently for each |
| sample. |
| The values for each sample must: be evaluated at the location of the sample. |
| The data associated with any other variables not decorated with code:Sample |
| and code:Input need not be evaluated independently for each sample. |
| |
| [[primsrast-multisampling-coverage-mask]] |
| A _coverage mask_ is generated for each fragment, based on which samples |
| within that fragment are determined to be within the area of the primitive |
| that generated the fragment. |
| |
| Single pixel fragments |
| ifdef::VK_EXT_fragment_density_map[] |
| and multi-pixel fragments defined by a |
| <<renderpass-fragmentdensitymapattachment, fragment density map>> |
| endif::VK_EXT_fragment_density_map[] |
| have one set of samples. |
| ifdef::VK_NV_shading_rate_image[] |
| Multi-pixel fragments defined by a <<primsrast-shading-rate-image, shading |
| rate image>> have one set of samples per pixel. |
| endif::VK_NV_shading_rate_image[] |
| ifdef::VK_KHR_fragment_shading_rate[] |
| Multi-pixel fragments defined by setting the |
| <<primsrast-fragment-shading-rate, fragment shading rate>> have one set of |
| samples per pixel. |
| endif::VK_KHR_fragment_shading_rate[] |
| Each set of samples has a number of samples determined by |
| slink:VkPipelineMultisampleStateCreateInfo::pname:rasterizationSamples. |
| Each sample in a set is assigned a unique _sample index_ [eq]#i# in the |
| range [eq]#[0, pname:rasterizationSamples)#. |
| |
| Each sample in a fragment is also assigned a unique _coverage index_ [eq]#j# |
| in the range [eq]#[0, n {times} pname:rasterizationSamples)#, where [eq]#n# |
| is the number of sets in the fragment. |
| If the fragment contains a single set of samples, the _coverage index_ is |
| always equal to the _sample index_. |
| ifdef::VK_NV_shading_rate_image[] |
| If a <<primsrast-shading-rate-image,shading rate image>> is used and a |
| fragment covers multiple pixels, the coverage index is determined as defined |
| by slink:VkPipelineViewportCoarseSampleOrderStateCreateInfoNV or |
| flink:vkCmdSetCoarseSampleOrderNV. |
| endif::VK_NV_shading_rate_image[] |
| |
| ifdef::VK_KHR_fragment_shading_rate[] |
| [[primsrast-multisampling-coverage-mask-vrfs]] |
| If the <<primsrast-fragment-shading-rate, fragment shading rate>> is set, |
| the coverage index [eq]#j# is determined as a function of the _pixel index_ |
| [eq]#p#, the _sample index_ [eq]#i#, and the number of rasterization samples |
| [eq]#r# as: |
| |
| {empty}:: [eq]#j = i + r {times} ((f~w~ * f~h~) - 1 - p)# |
| |
| where the pixel index [eq]#p# is determined as a function of the pixel's |
| framebuffer location [eq]#(x,y)# and the fragment size [eq]#(f~w~,f~h~)#: |
| |
| {empty}:: [eq]#p~x~ = x % f~w~# |
| {empty}:: [eq]#p~y~ = y % f~h~# |
| {empty}:: [eq]#p = p~x~ + (p~y~ * f~w~)# |
| |
| The table below illustrates the pixel index for multi-pixel fragments: |
| |
| .Pixel indices - 1 wide |
| [align="center"] |
| |==== |
| | 1x1 | 1x2 | 1x4 |
| |
| .>| image:{images}/pixel_index_1x1.svg[pdfwidth=90pt,opts="{imageopts}"] |
| .>| image:{images}/pixel_index_1x2.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| .>| image:{images}/pixel_index_1x4.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |==== |
| |
| .Pixel indices - 2 wide |
| [align="center"] |
| |==== |
| | 2x1 | 2x2 | 2x4 |
| |
| .>| image:{images}/pixel_index_2x1.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| .>| image:{images}/pixel_index_2x2.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| .>| image:{images}/pixel_index_2x4.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |==== |
| |
| .Pixel indices - 4 wide |
| [align="center"] |
| |==== |
| | 4x1 | 4x2 | 4x4 |
| |
| .>| image:{images}/pixel_index_4x1.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| .>| image:{images}/pixel_index_4x2.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| .>| image:{images}/pixel_index_4x4.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |==== |
| endif::VK_KHR_fragment_shading_rate[] |
| |
| The coverage mask includes [eq]#B# bits packed into [eq]#W# words, defined |
| as: |
| |
| {empty}:: [eq]#B = n {times} pname:rasterizationSamples# |
| {empty}:: [eq]#W = {lceil}B/32{rceil}# |
| |
| Bit [eq]#b# in coverage mask word [eq]#w# is `1` if the sample with coverage |
| index [eq]#j = 32*w + b# is covered, and `0` otherwise. |
| |
| If the pname:standardSampleLocations member of slink:VkPhysicalDeviceLimits |
| is ename:VK_TRUE, then the sample counts ename:VK_SAMPLE_COUNT_1_BIT, |
| ename:VK_SAMPLE_COUNT_2_BIT, ename:VK_SAMPLE_COUNT_4_BIT, |
| ename:VK_SAMPLE_COUNT_8_BIT, and ename:VK_SAMPLE_COUNT_16_BIT have sample |
| locations as listed in the following table, with the [eq]##i##th entry in |
| the table corresponding to sample index [eq]#i#. |
| ename:VK_SAMPLE_COUNT_32_BIT and ename:VK_SAMPLE_COUNT_64_BIT do not have |
| standard sample locations. |
| Locations are defined relative to an origin in the upper left corner of the |
| fragment. |
| |
| <<< |
| |
| .Standard sample locations |
| [options="header",align="center"] |
| |==== |
| | Sample count 2+| Sample Locations |
| |ename:VK_SAMPLE_COUNT_1_BIT |
| | [eq]#(0.5,0.5)# |
| | image:{images}/sample_count_1.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |ename:VK_SAMPLE_COUNT_2_BIT |
| | [eq]#(0.75,0.75)# + |
| [eq]#(0.25,0.25)# |
| | image:{images}/sample_count_2.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |ename:VK_SAMPLE_COUNT_4_BIT |
| | [eq]#(0.375, 0.125)# + |
| [eq]#(0.875, 0.375)# + |
| [eq]#(0.125, 0.625)# + |
| [eq]#(0.625, 0.875)# |
| | image:{images}/sample_count_4.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |ename:VK_SAMPLE_COUNT_8_BIT |
| | [eq]#(0.5625, 0.3125)# + |
| [eq]#(0.4375, 0.6875)# + |
| [eq]#(0.8125, 0.5625)# + |
| [eq]#(0.3125, 0.1875)# + |
| [eq]#(0.1875, 0.8125)# + |
| [eq]#(0.0625, 0.4375)# + |
| [eq]#(0.6875, 0.9375)# + |
| [eq]#(0.9375, 0.0625)# |
| | image:{images}/sample_count_8.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |ename:VK_SAMPLE_COUNT_16_BIT |
| | [eq]#(0.5625, 0.5625)# + |
| [eq]#(0.4375, 0.3125)# + |
| [eq]#(0.3125, 0.625)# + |
| [eq]#(0.75, 0.4375)# + |
| [eq]#(0.1875, 0.375)# + |
| [eq]#(0.625, 0.8125)# + |
| [eq]#(0.8125, 0.6875)# + |
| [eq]#(0.6875, 0.1875)# + |
| [eq]#(0.375, 0.875)# + |
| [eq]#(0.5, 0.0625)# + |
| [eq]#(0.25, 0.125)# + |
| [eq]#(0.125, 0.75)# + |
| [eq]#(0.0, 0.5)# + |
| [eq]#(0.9375, 0.25)# + |
| [eq]#(0.875, 0.9375)# + |
| [eq]#(0.0625, 0.0)# |
| | image:{images}/sample_count_16.svg[pdfwidth=90pt,align="center",opts="{imageopts}"] |
| |==== |
| |
| ifdef::VK_AMD_shader_fragment_mask[] |
| Color images created with multiple samples per pixel use a compression |
| technique where there are two arrays of data associated with each pixel. |
| The first array contains one element per sample where each element stores an |
| index to the second array defining the _fragment mask_ of the pixel. |
| The second array contains one element per _color fragment_ and each element |
| stores a unique color value in the format of the image. |
| With this compression technique it is not always necessary to actually use |
| unique storage locations for each color sample: when multiple samples share |
| the same color value the fragment mask may: have two samples referring to |
| the same color fragment. |
| The number of color fragments is determined by the pname:samples member of |
| the slink:VkImageCreateInfo structure used to create the image. |
| The `apiext:VK_AMD_shader_fragment_mask` device extension provides shader |
| instructions enabling the application to get direct access to the fragment |
| mask and the individual color fragment values. |
| |
| [[vk-amd-shader-fragment-mask-diagram]] |
| image::{images}/fragment_mask.svg[align="center",title="Fragment Mask",align="center",opts="{imageopts}"] |
| |
| endif::VK_AMD_shader_fragment_mask[] |
| |
| |
| ifdef::VK_EXT_sample_locations[] |
| [[primsrast-samplelocations]] |
| == Custom Sample Locations |
| |
| [open,refpage='VkPipelineSampleLocationsStateCreateInfoEXT',desc='Structure specifying sample locations for a pipeline',type='structs'] |
| -- |
| Applications can: also control the sample locations used for rasterization. |
| |
| If the pname:pNext chain of the slink:VkPipelineMultisampleStateCreateInfo |
| structure specified at pipeline creation time includes a |
| sname:VkPipelineSampleLocationsStateCreateInfoEXT structure, then that |
| structure controls the sample locations used when rasterizing primitives |
| with the pipeline. |
| |
| The sname:VkPipelineSampleLocationsStateCreateInfoEXT structure is defined |
| as: |
| |
| include::{generated}/api/structs/VkPipelineSampleLocationsStateCreateInfoEXT.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:sampleLocationsEnable controls whether custom sample locations are |
| used. |
| If pname:sampleLocationsEnable is ename:VK_FALSE, the default sample |
| locations are used and the values specified in pname:sampleLocationsInfo |
| are ignored. |
| * pname:sampleLocationsInfo is the sample locations to use during |
| rasterization if pname:sampleLocationsEnable is ename:VK_TRUE and the |
| graphics pipeline is not created with |
| ename:VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT. |
| |
| include::{generated}/validity/structs/VkPipelineSampleLocationsStateCreateInfoEXT.txt[] |
| -- |
| |
| [open,refpage='VkSampleLocationsInfoEXT',desc='Structure specifying a set of sample locations',type='structs'] |
| -- |
| The sname:VkSampleLocationsInfoEXT structure is defined as: |
| |
| include::{generated}/api/structs/VkSampleLocationsInfoEXT.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:sampleLocationsPerPixel is a elink:VkSampleCountFlagBits value |
| specifying the number of sample locations per pixel. |
| * pname:sampleLocationGridSize is the size of the sample location grid to |
| select custom sample locations for. |
| * pname:sampleLocationsCount is the number of sample locations in |
| pname:pSampleLocations. |
| * pname:pSampleLocations is a pointer to an array of |
| pname:sampleLocationsCount slink:VkSampleLocationEXT structures. |
| |
| This structure can: be used either to specify the sample locations to be |
| used for rendering or to specify the set of sample locations an image |
| subresource has been last rendered with for the purposes of layout |
| transitions of depth/stencil images created with |
| ename:VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT. |
| |
| The sample locations in pname:pSampleLocations specify |
| pname:sampleLocationsPerPixel number of sample locations for each pixel in |
| the grid of the size specified in pname:sampleLocationGridSize. |
| The sample location for sample [eq]#i# at the pixel grid location |
| [eq]#(x,y)# is taken from [eq]#pname:pSampleLocations[(x {plus} y {times} |
| pname:sampleLocationGridSize.width) {times} pname:sampleLocationsPerPixel |
| {plus} i]#. |
| |
| ifdef::VK_EXT_fragment_density_map[] |
| If the render pass has a fragment density map, the implementation will |
| choose the sample locations for the fragment and the contents of |
| pname:pSampleLocations may: be ignored. |
| endif::VK_EXT_fragment_density_map[] |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526]] |
| pname:sampleLocationsPerPixel must: be a bit value that is set in |
| slink:VkPhysicalDeviceSampleLocationsPropertiesEXT::pname:sampleLocationSampleCounts |
| * [[VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527]] |
| pname:sampleLocationsCount must: equal |
| [eq]#pname:sampleLocationsPerPixel {times} |
| pname:sampleLocationGridSize.width {times} |
| pname:sampleLocationGridSize.height# |
| **** |
| |
| include::{generated}/validity/structs/VkSampleLocationsInfoEXT.txt[] |
| -- |
| |
| [open,refpage='VkSampleLocationEXT',desc='Structure specifying the coordinates of a sample location',type='structs'] |
| -- |
| The sname:VkSampleLocationEXT structure is defined as: |
| |
| include::{generated}/api/structs/VkSampleLocationEXT.txt[] |
| |
| * pname:x is the horizontal coordinate of the sample's location. |
| * pname:y is the vertical coordinate of the sample's location. |
| |
| The domain space of the sample location coordinates has an upper-left origin |
| within the pixel in framebuffer space. |
| |
| The values specified in a sname:VkSampleLocationEXT structure are always |
| clamped to the implementation-dependent sample location coordinate range |
| [eq]#[pname:sampleLocationCoordinateRange[0],pname:sampleLocationCoordinateRange[1]]# |
| that can: be queried using |
| slink:VkPhysicalDeviceSampleLocationsPropertiesEXT. |
| |
| include::{generated}/validity/structs/VkSampleLocationEXT.txt[] |
| -- |
| |
| [open,refpage='vkCmdSetSampleLocationsEXT',desc='Set sample locations dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the sample locations used |
| for rasterization, call: |
| |
| include::{generated}/api/protos/vkCmdSetSampleLocationsEXT.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:pSampleLocationsInfo is the sample locations state to set. |
| |
| This command sets the custom sample locations for subsequent drawing |
| commands when the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates, and when the |
| slink:VkPipelineSampleLocationsStateCreateInfoEXT::pname:sampleLocationsEnable |
| property of the bound graphics pipeline is ename:VK_TRUE. |
| Otherwise, this state is specified by the |
| slink:VkPipelineSampleLocationsStateCreateInfoEXT::pname:sampleLocationsInfo |
| values used to create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529]] |
| The pname:sampleLocationsPerPixel member of pname:pSampleLocationsInfo |
| must: equal the pname:rasterizationSamples member of the |
| slink:VkPipelineMultisampleStateCreateInfo structure the bound graphics |
| pipeline has been created with |
| * [[VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530]] |
| If |
| slink:VkPhysicalDeviceSampleLocationsPropertiesEXT::pname:variableSampleLocations |
| is ename:VK_FALSE then the current render pass must: have been begun by |
| specifying a slink:VkRenderPassSampleLocationsBeginInfoEXT structure |
| whose pname:pPostSubpassSampleLocations member contains an element with |
| a pname:subpassIndex matching the current subpass index and the |
| pname:sampleLocationsInfo member of that element must: match the sample |
| locations state pointed to by pname:pSampleLocationsInfo |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetSampleLocationsEXT.txt[] |
| -- |
| endif::VK_EXT_sample_locations[] |
| |
| |
| ifdef::VK_KHR_fragment_shading_rate[] |
| [[primsrast-fragment-shading-rate]] |
| == Fragment Shading Rates |
| |
| The features advertised by |
| slink:VkPhysicalDeviceFragmentShadingRateFeaturesKHR allow an application to |
| control the <<glossary-shading-rate, shading rate>> of a given fragment |
| shader invocation. |
| |
| The fragment shading rate strongly interacts with <<primsrast-multisampling, |
| Multisampling>>, and the set of available rates for an implementation may: |
| be restricted by sample rate. |
| |
| [open,refpage='vkGetPhysicalDeviceFragmentShadingRatesKHR',desc='Get available shading rates for a physical device',type='protos'] |
| -- |
| To query available shading rates, call: |
| |
| include::{generated}/api/protos/vkGetPhysicalDeviceFragmentShadingRatesKHR.txt[] |
| |
| * pname:physicalDevice is the handle to the physical device whose |
| properties will be queried. |
| * pname:pFragmentShadingRateCount is a pointer to an integer related to |
| the number of fragment shading rates available or queried, as described |
| below. |
| * pname:pFragmentShadingRates is either `NULL` or a pointer to an array of |
| slink:VkPhysicalDeviceFragmentShadingRateKHR structures. |
| |
| If pname:pFragmentShadingRates is `NULL`, then the number of fragment |
| shading rates available is returned in pname:pFragmentShadingRateCount. |
| Otherwise, pname:pFragmentShadingRateCount must: point to a variable set by |
| the user to the number of elements in the pname:pFragmentShadingRates array, |
| and on return the variable is overwritten with the number of structures |
| actually written to pname:pFragmentShadingRates. |
| If pname:pFragmentShadingRateCount is less than the number of fragment |
| shading rates available, at most pname:pFragmentShadingRateCount structures |
| will be written, and ename:VK_INCOMPLETE will be returned instead of |
| ename:VK_SUCCESS, to indicate that not all the available fragment shading |
| rates were returned. |
| |
| The returned array of fragment shading rates must: be ordered from largest |
| pname:fragmentSize.width value to smallest, and each set of fragment shading |
| rates with the same pname:fragmentSize.width value must: be ordered from |
| largest pname:fragmentSize.height to smallest. |
| Any two entries in the array must: not have the same pname:fragmentSize |
| values. |
| |
| For any entry in the array, the following rules also apply: |
| |
| * The value of pname:fragmentSize.width must: be less than or equal to |
| <<limits-maxFragmentSize,pname:maxFragmentSize.width>>. |
| * The value of pname:fragmentSize.width must: be greater than or equal to |
| `1`. |
| * The value of pname:fragmentSize.width must: be a power-of-two. |
| * The value of pname:fragmentSize.height must: be less than or equal to |
| <<limits-maxFragmentSize,pname:maxFragmentSize.height>>. |
| * The value of pname:fragmentSize.height must: be greater than or equal to |
| `1`. |
| * The value of pname:fragmentSize.height must: be a power-of-two. |
| * The highest sample count in pname:sampleCounts must: be less than or |
| equal to <<limits-maxFragmentShadingRateRasterizationSamples, |
| pname:maxFragmentShadingRateRasterizationSamples>>. |
| * The product of pname:fragmentSize.width, pname:fragmentSize.height, and |
| the highest sample count in pname:sampleCounts must: be less than or |
| equal to <<limits-maxFragmentShadingRateCoverageSamples, |
| pname:maxFragmentShadingRateCoverageSamples>>. |
| |
| Implementations must: support at least the following shading rates: |
| |
| [options="autowidth"] |
| |=== |
| | pname:sampleCounts | pname:fragmentSize |
| |
| | ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT | {2,2} |
| | ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT | {2,1} |
| | ~0 | {1,1} |
| |=== |
| |
| If <<limits-framebufferColorSampleCounts, |
| pname:framebufferColorSampleCounts>>, includes ename:VK_SAMPLE_COUNT_2_BIT, |
| the required rates must: also include ename:VK_SAMPLE_COUNT_2_BIT. |
| |
| [NOTE] |
| .Note |
| ==== |
| Including the {1,1} fragment size is done for completeness; it has no actual |
| effect on the support of rendering without setting the fragment size. |
| All sample counts |
| ifdef::VK_QCOM_render_pass_transform[] |
| and render pass transforms |
| endif::VK_QCOM_render_pass_transform[] |
| are supported for this rate. |
| ==== |
| |
| ifdef::VK_QCOM_render_pass_transform[] |
| The returned set of fragment shading rates must: be returned in the native |
| (rotated) coordinate system. |
| For rasterization using render pass pname:transform not equal to |
| ename:VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, the application must: transform |
| the returned fragment shading rates into the current (unrotated) coordinate |
| system to get the supported rates for that transform. |
| |
| [NOTE] |
| .Note |
| ==== |
| For example, consider an implementation returning support for 4x2, but not |
| 2x4 in the set of supported fragment shading rates. |
| This means that for transforms ename:VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
| and ename:VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, 2x4 is a supported rate, |
| but 4x2 is an unsupported rate. |
| ==== |
| endif::VK_QCOM_render_pass_transform[] |
| |
| include::{generated}/validity/protos/vkGetPhysicalDeviceFragmentShadingRatesKHR.txt[] |
| -- |
| |
| [open,refpage='VkPhysicalDeviceFragmentShadingRateKHR',desc='Structure returning information about sample count specific additional multisampling capabilities',type='structs'] |
| -- |
| The sname:VkPhysicalDeviceFragmentShadingRateKHR structure is defined as |
| |
| include::{generated}/api/structs/VkPhysicalDeviceFragmentShadingRateKHR.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:sampleCounts is a bitmask of sample counts for which the shading |
| rate described by pname:fragmentSize is supported. |
| * pname:fragmentSize is a slink:VkExtent2D describing the width and height |
| of a supported shading rate. |
| |
| include::{generated}/validity/structs/VkPhysicalDeviceFragmentShadingRateKHR.txt[] |
| -- |
| |
| Fragment shading rates can: be set at three points, with the three rates |
| combined to determine the final shading rate. |
| |
| |
| [[primsrast-fragment-shading-rate-pipeline]] |
| === Pipeline Fragment Shading Rate |
| |
| The _pipeline fragment shading rate_ can: be set on a per-draw basis by |
| either setting the rate in a graphics pipeline, or dynamically via |
| flink:vkCmdSetFragmentShadingRateKHR. |
| |
| [open,refpage='VkPipelineFragmentShadingRateStateCreateInfoKHR',desc='Structure specifying parameters controlling the fragment shading rate',type='structs'] |
| -- |
| The sname:VkPipelineFragmentShadingRateStateCreateInfoKHR structure is |
| defined as: |
| |
| include::{generated}/api/structs/VkPipelineFragmentShadingRateStateCreateInfoKHR.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:fragmentSize specifies a slink:VkExtent2D structure containing the |
| fragment size used to define the pipeline fragment shading rate for |
| drawing commands using this pipeline. |
| * pname:combinerOps specifies a elink:VkFragmentShadingRateCombinerOpKHR |
| value determining how the |
| <<primsrast-fragment-shading-rate-pipeline,pipeline>>, |
| <<primsrast-fragment-shading-rate-primitive,primitive>>, and |
| <<primsrast-fragment-shading-rate-attachment,attachment shading rates>> |
| are <<primsrast-fragment-shading-rate-combining,combined>> for fragments |
| generated by drawing commands using the created pipeline. |
| |
| If the pname:pNext chain of slink:VkGraphicsPipelineCreateInfo includes a |
| sname:VkPipelineFragmentShadingRateStateCreateInfoKHR structure, then that |
| structure includes parameters that control the pipeline fragment shading |
| rate. |
| |
| If this structure is not present, pname:fragmentSize is considered to be |
| equal to [eq]#(1,1)#, and both elements of pname:combinerOps are considered |
| to be equal to ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR. |
| |
| include::{generated}/validity/structs/VkPipelineFragmentShadingRateStateCreateInfoKHR.txt[] |
| -- |
| |
| [open,refpage='vkCmdSetFragmentShadingRateKHR',desc='Set pipeline fragment shading rate and combiner operation dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the pipeline fragment |
| shading rate and combiner operation, call: |
| |
| include::{generated}/api/protos/vkCmdSetFragmentShadingRateKHR.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:pFragmentSize specifies the pipeline fragment shading rate for |
| subsequent drawing commands. |
| * pname:combinerOps specifies a elink:VkFragmentShadingRateCombinerOpKHR |
| determining how the |
| <<primsrast-fragment-shading-rate-pipeline,pipeline>>, |
| <<primsrast-fragment-shading-rate-primitive,primitive>>, and |
| <<primsrast-fragment-shading-rate-attachment,attachment shading rates>> |
| are <<primsrast-fragment-shading-rate-combining,combined>> for fragments |
| generated by subsequent drawing commands. |
| |
| This command sets the pipeline fragment shading rate and combiner operation |
| for subsequent drawing commands when the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineFragmentShadingRateStateCreateInfoKHR values used to create |
| the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04507]] |
| If <<features-pipelineFragmentShadingRate, |
| pname:pipelineFragmentShadingRate>> is not enabled, |
| pname:pFragmentSize->width must: be `1` |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04508]] |
| If <<features-pipelineFragmentShadingRate, |
| pname:pipelineFragmentShadingRate>> is not enabled, |
| pname:pFragmentSize->height must: be `1` |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04509]] |
| One of <<features-pipelineFragmentShadingRate, |
| pname:pipelineFragmentShadingRate>>, |
| <<features-primitiveFragmentShadingRate, |
| pname:primitiveFragmentShadingRate>>, or |
| <<features-attachmentFragmentShadingRate, |
| pname:attachmentFragmentShadingRate>> must: be enabled |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-primitiveFragmentShadingRate-04510]] |
| If the <<features-primitiveFragmentShadingRate, |
| pname:primitiveFragmentShadingRate feature>> is not enabled, |
| pname:combinerOps[0] must: be |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-attachmentFragmentShadingRate-04511]] |
| If the <<features-attachmentFragmentShadingRate, |
| pname:attachmentFragmentShadingRate feature>> is not enabled, |
| pname:combinerOps[1] must: be |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-fragmentSizeNonTrivialCombinerOps-04512]] |
| If the <<limits-fragmentShadingRateNonTrivialCombinerOps, |
| pname:fragmentSizeNonTrivialCombinerOps>> limit is not supported, |
| elements of pname:combinerOps must: be either |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04513]] |
| pname:pFragmentSize->width must: be greater than or equal to `1` |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04514]] |
| pname:pFragmentSize->height must: be greater than or equal to `1` |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04515]] |
| pname:pFragmentSize->width must: be a power-of-two value |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04516]] |
| pname:pFragmentSize->height must: be a power-of-two value |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04517]] |
| pname:pFragmentSize->width must: be less than or equal to `4` |
| * [[VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04518]] |
| pname:pFragmentSize->height must: be less than or equal to `4` |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetFragmentShadingRateKHR.txt[] |
| -- |
| |
| |
| [[primsrast-fragment-shading-rate-primitive]] |
| === Primitive Fragment Shading Rate |
| |
| The _primitive fragment shading rate_ can: be set via the |
| <<interfaces-builtin-variables-primitiveshadingrate, |
| code:PrimitiveShadingRateKHR>> built-in in the last active |
| <<pipeline-graphics-subsets-pre-rasterization,pre-rasterization shader |
| stage>>. |
| The rate associated with a given primitive is sourced from the value written |
| to code:PrimitiveShadingRateKHR by that primitive's |
| <<vertexpostproc-flatshading,provoking vertex>>. |
| |
| |
| [[primsrast-fragment-shading-rate-attachment]] |
| === Attachment Fragment Shading Rate |
| |
| The _attachment shading rate_ can: be set by including |
| slink:VkFragmentShadingRateAttachmentInfoKHR in a subpass to define a |
| _fragment shading rate attachment_. |
| Each pixel in the framebuffer is assigned an attachment fragment shading |
| rate by the corresponding texel in the fragment shading rate attachment, |
| according to: |
| |
| {empty}:: [eq]#x' = floor(x / region~x~)# |
| {empty}:: [eq]#y' = floor(y / region~y~)# |
| |
| where [eq]#x'# and [eq]#y'# are the coordinates of a texel in the fragment |
| shading rate attachment, [eq]#x# and [eq]#y# are the coordinates of the |
| pixel in the framebuffer, and [eq]#region~x~# and [eq]#region~y~# are the |
| size of the region each texel corresponds to, as defined by the |
| pname:shadingRateAttachmentTexelSize member of |
| slink:VkFragmentShadingRateAttachmentInfoKHR. |
| |
| If <<VkRenderPassMultiviewCreateInfo, multiview is enabled>> and the shading |
| rate attachment has multiple layers, the shading rate attachment texel is |
| selected from the layer determined by the |
| <<interfaces-builtin-variables-viewindex,code:ViewIndex>> built-in. |
| If <<VkRenderPassMultiviewCreateInfo, multiview is disabled>>, and both the |
| shading rate attachment and the framebuffer have multiple layers, the |
| shading rate attachment texel is selected from the layer determined by the |
| <<interfaces-builtin-variables-layer,code:Layer>> built-in. |
| Otherwise, the texel is unconditionally selected from the first layer of the |
| attachment. |
| |
| The fragment size is encoded into the first component of the identified |
| texel as follows: |
| |
| {empty}:: [eq]#size~w~ = 2^((texel/4)&3)^# |
| {empty}:: [eq]#size~h~ = 2^(texel&3)^# |
| |
| where [eq]#texel# is the value in the first component of the identified |
| texel, and [eq]#size~w~# and [eq]#size~h~# are the width and height of the |
| fragment size, decoded from the texel. |
| |
| If no fragment shading rate attachment is specified, this size is calculated |
| as [eq]#size~w~ = size~h~ = 1#. |
| Applications must: not specify a width or height greater than 4 by this |
| method. |
| |
| The _Fragment Shading Rate_ enumeration in SPIR-V adheres to the above |
| encoding. |
| |
| |
| [[primsrast-fragment-shading-rate-combining]] |
| === Combining the Fragment Shading Rates |
| |
| The final rate ([eq]#C~xy~'#) used for fragment shading must: be one of the |
| rates returned by flink:vkGetPhysicalDeviceFragmentShadingRatesKHR for the |
| sample count |
| ifdef::VK_QCOM_render_pass_transform[] |
| and render pass transform |
| endif::VK_QCOM_render_pass_transform[] |
| used by rasterization. |
| |
| If any of the following conditions are met, [eq]#C~xy~'# must: be set to |
| [eq]#{1,1}#: |
| |
| * If <<primsrast-sampleshading,Sample Shading>> is enabled. |
| * The <<limits-fragmentShadingRateWithSampleMask, |
| pname:fragmentShadingRateWithSampleMask>> limit is not supported, and |
| slink:VkPipelineMultisampleStateCreateInfo::pname:pSampleMask contains a |
| zero value in any bit used by fragment operations. |
| * The <<limits-fragmentShadingRateWithShaderSampleMask, |
| pname:fragmentShadingRateWithShaderSampleMask>> is not supported, and |
| the fragment shader has code:SampleMask in the input or output |
| interface. |
| * The <<limits-fragmentShadingRateWithShaderDepthStencilWrites, |
| pname:fragmentShadingRateWithShaderDepthStencilWrites>> limit is not |
| supported, and the fragment shader declares the code:FragDepth |
| ifdef::VK_EXT_shader_stencil_export[] |
| or code:FragStencilRefEXT |
| endif::VK_EXT_shader_stencil_export[] |
| built-in. |
| ifdef::VK_EXT_conservative_rasterization[] |
| * The <<limits-fragmentShadingRateWithConservativeRasterization, |
| pname:fragmentShadingRateWithConservativeRasterization>> limit is not |
| supported, and |
| slink:VkPipelineRasterizationConservativeStateCreateInfoEXT::pname:conservativeRasterizationMode |
| is not ename:VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT. |
| endif::VK_EXT_conservative_rasterization[] |
| ifdef::VK_EXT_fragment_shader_interlock[] |
| * The <<limits-fragmentShadingRateWithFragmentShaderInterlock, |
| pname:fragmentShadingRateWithFragmentShaderInterlock>> limit is not |
| supported, and the fragment shader declares any of the |
| <<fragops-shader-interlock, fragment shader interlock>> execution modes. |
| endif::VK_EXT_fragment_shader_interlock[] |
| ifdef::VK_EXT_sample_locations[] |
| * The <<limits-fragmentShadingRateWithCustomSampleLocations, |
| pname:fragmentShadingRateWithCustomSampleLocations>> limit is not |
| supported, and |
| slink:VkPipelineSampleLocationsStateCreateInfoEXT::pname:sampleLocationsEnable |
| is ename:VK_TRUE. |
| endif::VK_EXT_sample_locations[] |
| |
| Otherwise, each of the specified shading rates are combined and then used to |
| derive the value of [eq]#C~xy~'#. |
| As there are three ways to specify shading rates, two combiner operations |
| are specified - between the |
| <<primsrast-fragment-shading-rate-pipeline,pipeline>> and |
| <<primsrast-fragment-shading-rate-primitive,primitive>> shading rates, and |
| between the result of that and the |
| <<primsrast-fragment-shading-rate-attachment,attachment shading rate>>. |
| |
| [open,refpage='VkFragmentShadingRateCombinerOpKHR',desc='Control how fragment shading rates are combined',type='enums'] |
| -- |
| The equation used for each combiner operation is defined by |
| ename:VkFragmentShadingRateCombinerOpKHR: |
| |
| include::{generated}/api/enums/VkFragmentShadingRateCombinerOpKHR.txt[] |
| |
| * ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR specifies a combiner |
| operation of [eq]#combine(A~xy~,B~xy~) = A~xy~#. |
| * ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR specifies a |
| combiner operation of [eq]#combine(A~xy~,B~xy~) = B~xy~#. |
| * ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR specifies a combiner |
| operation of [eq]#combine(A~xy~,B~xy~) = min(A~xy~,B~xy~)#. |
| * ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR specifies a combiner |
| operation of [eq]#combine(A~xy~,B~xy~) = max(A~xy~,B~xy~)#. |
| * ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR specifies a combiner |
| operation of [eq]#combine(A~xy~,B~xy~) = A~xy~*B~xy~#. |
| |
| where [eq]#combine(A~xy~,B~xy~)# is the combine operation, and [eq]#A~xy~# |
| and [eq]#B~xy~# are the inputs to the operation. |
| |
| If <<limits-fragmentShadingRateStrictMultiplyCombiner, |
| pname:fragmentShadingRateStrictMultiplyCombiner>> is ename:VK_FALSE, using |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR with values of 1 for both |
| A and B in the same dimension results in the value 2 being produced for that |
| dimension. |
| See the definition of <<limits-fragmentShadingRateStrictMultiplyCombiner, |
| pname:fragmentShadingRateStrictMultiplyCombiner>> for more information. |
| |
| These operations are performed in a component-wise fashion. |
| -- |
| |
| This is used to generate a combined fragment area using the equation: |
| |
| {empty}:: [eq]#C~xy~ = combine(A~xy~,B~xy~)# |
| |
| where [eq]#C~xy~# is the combined fragment area result, and [eq]#A~xy~# and |
| [eq]#B~xy~# are the fragment areas of the fragment shading rates being |
| combined. |
| |
| Two combine operations are performed, first with [eq]#A~xy~# equal to the |
| <<primsrast-fragment-shading-rate-pipeline,pipeline fragment shading rate>> |
| and [eq]#B~xy~# equal to the <<primsrast-fragment-shading-rate-primitive, |
| primitive fragment shading rate>>, with the [eq]#combine()# operation |
| selected by combinerOps[0]. |
| A second combination is then performed, with [eq]#A~xy~# equal to the result |
| of the first combination and [eq]#B~xy~# equal to the |
| <<primsrast-fragment-shading-rate-attachment, attachment fragment shading |
| rate>>, with the [eq]#combine()# operation selected by combinerOps[1]. |
| The result of the second combination is used as the final fragment shading |
| rate, reported via the <<interfaces-builtin-variables-primitiveshadingrate, |
| code:ShadingRateKHR built-in>>. |
| |
| Implementations may: clamp the [eq]#C~xy~# result of each combiner operation |
| separately, or only after the second combiner operation. |
| |
| If the final combined rate is one of the rates returned by |
| flink:vkGetPhysicalDeviceFragmentShadingRatesKHR for the sample count |
| ifdef::VK_QCOM_render_pass_transform[] |
| and render pass transform |
| endif::VK_QCOM_render_pass_transform[] |
| used by rasterization, [eq]#C~xy~' = C~xy~#. |
| Otherwise, [eq]#C~xy~'# is selected from the rates returned by |
| flink:vkGetPhysicalDeviceFragmentShadingRatesKHR for the sample count |
| ifdef::VK_QCOM_render_pass_transform[] |
| and render pass transform |
| endif::VK_QCOM_render_pass_transform[] |
| used by rasterization. |
| From this list of supported rates, the following steps are applied in order, |
| to select a single value: |
| |
| . Keep only rates where [eq]#C~x~' {leq} C~x~# and [eq]#C~y~' {leq} C~y~#. |
| ** Implementations may: also keep rates where [eq]#C~x~' {leq} C~y~# and |
| [eq]#C~y~' {leq} C~x~#. |
| . Keep only rates with the highest area ([eq]#C~x~' {times} C~y~'#). |
| . Keep only rates with the lowest aspect ratio ([eq]#C~x~' {plus} C~y~'#). |
| . In cases where a wide (e.g. 4x1) and tall (e.g. 1x4) rate remain, the |
| implementation may: choose either rate. |
| However, it must: choose this rate consistently for the same shading |
| rates, |
| ifdef::VK_QCOM_render_pass_transform[] |
| render pass transform, |
| endif::VK_QCOM_render_pass_transform[] |
| and combiner operations for the lifetime of the slink:VkDevice. |
| endif::VK_KHR_fragment_shading_rate[] |
| |
| |
| ifdef::VK_NV_fragment_shading_rate_enums[] |
| === Extended Fragment Shading Rates |
| |
| The features advertised by |
| slink:VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV provide support for |
| additional fragment shading rates beyond those specifying one fragment |
| shader invocation covering all pixels in a fragment whose size is indicated |
| by the fragment shading rate. |
| |
| [open,refpage='VkFragmentShadingRateNV',desc='Enumeration with fragment shading rates',type='enums'] |
| -- |
| If the pname:fragmentShadingRateEnums feature is enabled, fragment shading |
| rates may be specified using the elink:VkFragmentShadingRateNV enumerated |
| type defined as: |
| |
| include::{generated}/api/enums/VkFragmentShadingRateNV.txt[] |
| |
| * ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV specifies a |
| fragment size of 1x1 pixels. |
| * ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV specifies |
| a fragment size of 1x2 pixels. |
| * ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV specifies |
| a fragment size of 2x1 pixels. |
| * ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV specifies |
| a fragment size of 2x2 pixels. |
| * ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV specifies |
| a fragment size of 2x4 pixels. |
| * ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV specifies |
| a fragment size of 4x2 pixels. |
| * ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV specifies |
| a fragment size of 4x4 pixels. |
| * ename:VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV specifies a |
| fragment size of 1x1 pixels, with two fragment shader invocations per |
| fragment. |
| * ename:VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV specifies a |
| fragment size of 1x1 pixels, with four fragment shader invocations per |
| fragment. |
| * ename:VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV specifies a |
| fragment size of 1x1 pixels, with eight fragment shader invocations per |
| fragment. |
| * ename:VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV specifies a |
| fragment size of 1x1 pixels, with sixteen fragment shader invocations |
| per fragment. |
| * ename:VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV specifies that any |
| portions of a primitive that use that shading rate should be discarded |
| without invoking any fragment shader. |
| |
| To use the shading rates |
| ename:VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, |
| ename:VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, |
| ename:VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, and |
| ename:VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV as a pipeline, |
| primitive, or attachment shading rate, the |
| pname:supersampleFragmentShadingRates feature must: be enabled. |
| To use the shading rate ename:VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV as |
| a pipeline, primitive, or attachment shading rate, the |
| pname:noInvocationFragmentShadingRates feature must: be enabled. |
| -- |
| |
| When using fragment shading rate enums, the pipeline fragment shading rate |
| can: be set on a per-draw basis by either setting the rate in a graphics |
| pipeline, or dynamically via flink:vkCmdSetFragmentShadingRateEnumNV. |
| |
| [open,refpage='VkPipelineFragmentShadingRateEnumStateCreateInfoNV',desc='Structure specifying parameters controlling the fragment shading rate using rate enums',type='structs'] |
| -- |
| The sname:VkPipelineFragmentShadingRateEnumStateCreateInfoNV structure is |
| defined as: |
| |
| include::{generated}/api/structs/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:shadingRateType specifies a elink:VkFragmentShadingRateTypeNV |
| value indicating whether fragment shading rates are specified using |
| fragment sizes or elink:VkFragmentShadingRateNV enums. |
| * pname:shadingRate specifies a elink:VkFragmentShadingRateNV value |
| indicating the pipeline fragment shading rate. |
| * pname:combinerOps specifies elink:VkFragmentShadingRateCombinerOpKHR |
| values determining how the |
| <<primsrast-fragment-shading-rate-pipeline,pipeline>>, |
| <<primsrast-fragment-shading-rate-primitive,primitive>>, and |
| <<primsrast-fragment-shading-rate-attachment,attachment shading rates>> |
| are <<primsrast-fragment-shading-rate-combining,combined>> for fragments |
| generated by drawing commands using the created pipeline. |
| |
| If the pname:pNext chain of slink:VkGraphicsPipelineCreateInfo includes a |
| sname:VkPipelineFragmentShadingRateEnumStateCreateInfoNV structure, then |
| that structure includes parameters that control the pipeline fragment |
| shading rate. |
| |
| If this structure is not present, pname:shadingRateType is considered to be |
| equal to ename:VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV, |
| pname:shadingRate is considered to be equal to |
| ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV, and both elements |
| of pname:combinerOps are considered to be equal to |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR. |
| |
| include::{generated}/validity/structs/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.txt[] |
| -- |
| |
| [open,refpage='VkFragmentShadingRateTypeNV',desc='Enumeration with fragment shading rate types',type='enums'] |
| -- |
| The elink:VkFragmentShadingRateTypeNV enumerated type specifies whether a |
| graphics pipeline gets its pipeline fragment shading rates and combiners |
| from the slink:VkPipelineFragmentShadingRateEnumStateCreateInfoNV structure |
| or the slink:VkPipelineFragmentShadingRateStateCreateInfoKHR structure. |
| |
| include::{generated}/api/enums/VkFragmentShadingRateTypeNV.txt[] |
| |
| * ename:VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV specifies that a |
| graphics pipeline should obtain its pipeline fragment shading rate and |
| shading rate combiner state from the |
| slink:VkPipelineFragmentShadingRateStateCreateInfoKHR structure and that |
| any state specified by the |
| slink:VkPipelineFragmentShadingRateEnumStateCreateInfoNV structure |
| should be ignored. |
| * ename:VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV specifies that a graphics |
| pipeline should obtain its pipeline fragment shading rate and shading |
| rate combiner state from the |
| slink:VkPipelineFragmentShadingRateEnumStateCreateInfoNV structure and |
| that any state specified by the |
| slink:VkPipelineFragmentShadingRateStateCreateInfoKHR structure should |
| be ignored. |
| -- |
| |
| [open,refpage='vkCmdSetFragmentShadingRateEnumNV',desc='Set pipeline fragment shading rate dynamically for a command buffer using enums',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the pipeline fragment |
| shading rate and combiner operation, call: |
| |
| include::{generated}/api/protos/vkCmdSetFragmentShadingRateEnumNV.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:shadingRate specifies a elink:VkFragmentShadingRateNV enum |
| indicating the pipeline fragment shading rate for subsequent drawing |
| commands. |
| * pname:combinerOps specifies a elink:VkFragmentShadingRateCombinerOpKHR |
| determining how the |
| <<primsrast-fragment-shading-rate-pipeline,pipeline>>, |
| <<primsrast-fragment-shading-rate-primitive,primitive>>, and |
| <<primsrast-fragment-shading-rate-attachment,attachment shading rates>> |
| are <<primsrast-fragment-shading-rate-combining,combined>> for fragments |
| generated by subsequent drawing commands. |
| |
| This command sets the pipeline fragment shading rate and combiner operation |
| for subsequent drawing commands when the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineFragmentShadingRateEnumStateCreateInfoNV values used to |
| create the currently active pipeline. |
| |
| [NOTE] |
| .Note |
| ==== |
| This command allows specifying additional shading rates beyond those |
| supported by flink:vkCmdSetFragmentShadingRateKHR. |
| For more information, refer to the |
| `apiext:VK_NV_fragment_shading_rate_enums` appendix. |
| ==== |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-pipelineFragmentShadingRate-04576]] |
| If <<features-pipelineFragmentShadingRate, |
| pname:pipelineFragmentShadingRate>> is not enabled, pname:shadingRate |
| must: be ename:VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-supersampleFragmentShadingRates-04577]] |
| If <<features-supersampleFragmentShadingRates, |
| pname:supersampleFragmentShadingRates>> is not enabled, |
| pname:shadingRate must: not be |
| ename:VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, |
| ename:VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, |
| ename:VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, or |
| ename:VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-noInvocationFragmentShadingRates-04578]] |
| If <<features-noInvocationFragmentShadingRates, |
| pname:noInvocationFragmentShadingRates>> is not enabled, |
| pname:shadingRate must: not be |
| ename:VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-fragmentShadingRateEnums-04579]] |
| <<features-fragmentShadingRateEnums,pname:fragmentShadingRateEnums>> |
| must: be enabled |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-pipelineFragmentShadingRate-04580]] |
| One of <<features-pipelineFragmentShadingRate, |
| pname:pipelineFragmentShadingRate>>, |
| <<features-primitiveFragmentShadingRate, |
| pname:primitiveFragmentShadingRate>>, or |
| <<features-attachmentFragmentShadingRate, |
| pname:attachmentFragmentShadingRate>> must: be enabled |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-primitiveFragmentShadingRate-04581]] |
| If the <<features-primitiveFragmentShadingRate, |
| pname:primitiveFragmentShadingRate feature>> is not enabled, |
| pname:combinerOps[0] must: be |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-attachmentFragmentShadingRate-04582]] |
| If the <<features-attachmentFragmentShadingRate, |
| pname:attachmentFragmentShadingRate feature>> is not enabled, |
| pname:combinerOps[1] must: be |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR |
| * [[VUID-vkCmdSetFragmentShadingRateEnumNV-fragmentSizeNonTrivialCombinerOps-04583]] |
| If the <<limits-fragmentShadingRateNonTrivialCombinerOps, |
| pname:fragmentSizeNonTrivialCombinerOps>> limit is not supported, |
| elements of pname:combinerOps must: be either |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetFragmentShadingRateEnumNV.txt[] |
| -- |
| |
| When the <<features-supersampleFragmentShadingRates, |
| pname:supersampleFragmentShadingRates>> or |
| <<features-noInvocationFragmentShadingRates, |
| pname:noInvocationFragmentShadingRates>> features are enabled, the behavior |
| of the <<primsrast-fragment-shading-rate-combining,shading rate combiner |
| operations>> is extended to support the shading rates enabled by those |
| features. |
| Primitive and attachment shading rate values are interpreted as |
| elink:VkFragmentShadingRateNV values and the behavior of the combiners is |
| modified as follows: |
| |
| * For ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, and |
| ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR, if either |
| [eq]#A~xy~# or [eq]#B~xy~# is |
| ename:VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV, |
| [eq]#combine(A~xy~,B~xy~)# produces a shading rate of |
| ename:VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV, regardless of the |
| other input shading rate. |
| * For ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, |
| [eq]#combine(A~xy~,B~xy~)# produces a shading rate whose fragment size |
| is the smaller of the fragment sizes of [eq]#A~xy~# and [eq]#B~xy~# and |
| whose invocation count is the larger of the invocation counts of |
| [eq]#A~xy~# and [eq]#B~xy~#. |
| * For ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, |
| [eq]#combine(A~xy~,B~xy~)# produces a shading rate whose fragment size |
| is the larger of the fragment sizes of [eq]#A~xy~# and [eq]#B~xy~# and |
| whose invocation count is the smaller of the invocation counts of |
| [eq]#A~xy~# and [eq]#B~xy~#. |
| * For ename:VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR, |
| [eq]#combine(A~xy~,B~xy~)# produces a shading rate whose fragment size |
| and invocation count is the product of the fragment sizes and invocation |
| counts, respectively, of [eq]#A~xy~# and [eq]#B~xy~#. |
| If the resulting shading rate has both multiple pixels and multiple |
| invocations per fragment, an implementation may: adjust the shading rate |
| by reducing both the pixel and invocation counts. |
| |
| If the final shading rate from the combiners is |
| ename:VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV, no fragments will be |
| generated for any portion of a primitive using that shading rate. |
| |
| If the final shading rate from the combiners specifies multiple fragment |
| shader invocations per fragment, the fragment will be processed with |
| multiple unique samples as in <<primsrast-sampleshading, sample shading>>, |
| where the total number the total number of invocations is taken from the |
| shading rate and then clamped to the value of code:totalSamples used by |
| sample shading and to the value of |
| <<limits-maxFragmentShadingRateInvocationCount, |
| pname:maxFragmentShadingRateInvocationCount>>. |
| |
| endif::VK_NV_fragment_shading_rate_enums[] |
| |
| |
| ifdef::VK_NV_shading_rate_image[] |
| [[primsrast-shading-rate-image]] |
| == Shading Rate Image |
| |
| The <<features-shadingRateImage, shading rate image>> feature allows |
| pipelines to use a <<glossary-shading-rate-image,shading rate image>> to |
| control the <<glossary-fragment-area, fragment area>> and the minimum number |
| of fragment shader invocations launched for each fragment. |
| When the shading rate image is enabled, the rasterizer determines a base |
| <<glossary-shading-rate,shading rate>> for each region of the framebuffer |
| covered by a primitive by fetching a value from the shading rate image and |
| translating it to a shading rate using a per-viewport shading rate palette. |
| This base shading rate is then adjusted to derive a final shading rate. |
| The final shading rate specifies the fragment area and fragment shader |
| invocation count to use for fragments generated in the region. |
| |
| [open,refpage='VkPipelineViewportShadingRateImageStateCreateInfoNV',desc='Structure specifying parameters controlling shading rate image usage',type='structs'] |
| -- |
| If the pname:pNext chain of slink:VkPipelineViewportStateCreateInfo includes |
| a sname:VkPipelineViewportShadingRateImageStateCreateInfoNV structure, then |
| that structure includes parameters that control the shading rate. |
| |
| The sname:VkPipelineViewportShadingRateImageStateCreateInfoNV structure is |
| defined as: |
| |
| include::{generated}/api/structs/VkPipelineViewportShadingRateImageStateCreateInfoNV.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:shadingRateImageEnable specifies whether shading rate image and |
| palettes are used during rasterization. |
| * pname:viewportCount specifies the number of per-viewport palettes used |
| to translate values stored in shading rate images. |
| * pname:pShadingRatePalettes is a pointer to an array of |
| slink:VkShadingRatePaletteNV structures defining the palette for each |
| viewport. |
| If the shading rate palette state is dynamic, this member is ignored. |
| |
| If this structure is not present, pname:shadingRateImageEnable is considered |
| to be ename:VK_FALSE, and the shading rate image and palettes are not used. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02054]] |
| If the <<features-multiViewport,multiple viewports>> feature is not |
| enabled, pname:viewportCount must: be `0` or `1` |
| * [[VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02055]] |
| pname:viewportCount must: be less than or equal to |
| sname:VkPhysicalDeviceLimits::pname:maxViewports |
| * [[VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-shadingRateImageEnable-02056]] |
| If pname:shadingRateImageEnable is ename:VK_TRUE, pname:viewportCount |
| must: be greater or equal to the pname:viewportCount member of |
| slink:VkPipelineViewportStateCreateInfo |
| **** |
| include::{generated}/validity/structs/VkPipelineViewportShadingRateImageStateCreateInfoNV.txt[] |
| -- |
| |
| [open,refpage='vkCmdBindShadingRateImageNV',desc='Bind a shading rate image on a command buffer',type='protos'] |
| -- |
| When shading rate image usage is enabled in the bound pipeline, the pipeline |
| uses a shading rate image specified by the command: |
| |
| include::{generated}/api/protos/vkCmdBindShadingRateImageNV.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:imageView is an image view handle specifying the shading rate |
| image. |
| pname:imageView may: be set to dlink:VK_NULL_HANDLE, which is equivalent |
| to specifying a view of an image filled with zero values. |
| * pname:imageLayout is the layout that the image subresources accessible |
| from pname:imageView will be in when the shading rate image is accessed. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdBindShadingRateImageNV-None-02058]] |
| The <<features-shadingRateImage,shading rate image>> feature must: be |
| enabled |
| * [[VUID-vkCmdBindShadingRateImageNV-imageView-02059]] |
| If pname:imageView is not dlink:VK_NULL_HANDLE, it must: be a valid |
| slink:VkImageView handle of type ename:VK_IMAGE_VIEW_TYPE_2D or |
| ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY |
| * [[VUID-vkCmdBindShadingRateImageNV-imageView-02060]] |
| If pname:imageView is not dlink:VK_NULL_HANDLE, it must: have a format |
| of ename:VK_FORMAT_R8_UINT |
| * [[VUID-vkCmdBindShadingRateImageNV-imageView-02061]] |
| If pname:imageView is not dlink:VK_NULL_HANDLE, it must: have been |
| created with a pname:usage value including |
| ename:VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV |
| * [[VUID-vkCmdBindShadingRateImageNV-imageView-02062]] |
| If pname:imageView is not dlink:VK_NULL_HANDLE, pname:imageLayout must: |
| match the actual elink:VkImageLayout of each subresource accessible from |
| pname:imageView at the time the subresource is accessed |
| * [[VUID-vkCmdBindShadingRateImageNV-imageLayout-02063]] |
| If pname:imageView is not dlink:VK_NULL_HANDLE, pname:imageLayout must: |
| be ename:VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV or |
| ename:VK_IMAGE_LAYOUT_GENERAL |
| **** |
| |
| include::{generated}/validity/protos/vkCmdBindShadingRateImageNV.txt[] |
| -- |
| |
| When the shading rate image is enabled in the current pipeline, rasterizing |
| a primitive covering the pixel with coordinates (_x_,_y_) will fetch a |
| shading rate index value from the shading rate image bound by |
| fname:vkCmdBindShadingRateImageNV. |
| If the shading rate image view has a type of ename:VK_IMAGE_VIEW_TYPE_2D, |
| the lookup will use texel coordinates (_u_,_v_) where latexmath:[u = |
| \left\lfloor \frac{x}{twidth} \right\rfloor], latexmath:[v = \left\lfloor |
| \frac{y}{theight} \right\rfloor], and latexmath:[twidth] and |
| latexmath:[theight] are the width and height of the implementation-dependent |
| <<limits-shading-rate-texel-size, shading rate texel size>>. |
| If the shading rate image view has a type of |
| ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY, the lookup will use texel coordinates |
| (_u_,_v_) to extract a texel from the layer _l_, where _l_ is the layer of |
| the framebuffer being rendered to. |
| If _l_ is greater than or equal to the number of layers in the image view, |
| layer zero will be used. |
| |
| If the bound shading rate image view is not dlink:VK_NULL_HANDLE and |
| contains a texel with coordinates (_u_,_v_) in layer _l_ (if applicable), |
| the single unsigned integer component for that texel will be used as the |
| shading rate index. |
| If the (_u_,_v_) coordinate is outside the extents of the subresource used |
| by the shading rate image view, or if the image view is |
| dlink:VK_NULL_HANDLE, the shading rate index is zero. |
| If the shading rate image view has multiple mipmap levels, the base level |
| identified by sname:VkImageSubresourceRange::pname:baseMipLevel will be |
| used. |
| |
| A shading rate index is mapped to a base shading rate using a lookup table |
| called the shading rate image palette. |
| There is a separate palette for each viewport. |
| The number of entries in each palette is given by the |
| implementation-dependent <<limits-shading-rate-palette-size, shading rate |
| image palette size>>. |
| |
| [open,refpage='vkCmdSetViewportShadingRatePaletteNV',desc='Set shading rate image palettes dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the per-viewport shading |
| rate image palettes, call: |
| |
| include::{generated}/api/protos/vkCmdSetViewportShadingRatePaletteNV.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:firstViewport is the index of the first viewport whose shading |
| rate palette is updated by the command. |
| * pname:viewportCount is the number of viewports whose shading rate |
| palettes are updated by the command. |
| * pname:pShadingRatePalettes is a pointer to an array of |
| slink:VkShadingRatePaletteNV structures defining the palette for each |
| viewport. |
| |
| This command sets the per-viewport shading rate image palettes for |
| subsequent drawing commands when the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineViewportShadingRateImageStateCreateInfoNV::pname:pShadingRatePalettes |
| values used to create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetViewportShadingRatePaletteNV-None-02064]] |
| The <<features-shadingRateImage,shading rate image>> feature must: be |
| enabled |
| * [[VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02067]] |
| The sum of pname:firstViewport and pname:viewportCount must: be between |
| `1` and sname:VkPhysicalDeviceLimits::pname:maxViewports, inclusive |
| * [[VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02068]] |
| If the <<features-multiViewport,multiple viewports>> feature is not |
| enabled, pname:firstViewport must: be `0` |
| * [[VUID-vkCmdSetViewportShadingRatePaletteNV-viewportCount-02069]] |
| If the <<features-multiViewport,multiple viewports>> feature is not |
| enabled, pname:viewportCount must: be `1` |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetViewportShadingRatePaletteNV.txt[] |
| -- |
| |
| [open,refpage='VkShadingRatePaletteNV',desc='Structure specifying a single shading rate palette',type='structs'] |
| -- |
| The sname:VkShadingRatePaletteNV structure specifies to contents of a single |
| shading rate image palette and is defined as: |
| |
| include::{generated}/api/structs/VkShadingRatePaletteNV.txt[] |
| |
| * pname:shadingRatePaletteEntryCount specifies the number of entries in |
| the shading rate image palette. |
| * pname:pShadingRatePaletteEntries is a pointer to an array of |
| elink:VkShadingRatePaletteEntryNV enums defining the shading rate for |
| each palette entry. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkShadingRatePaletteNV-shadingRatePaletteEntryCount-02071]] |
| pname:shadingRatePaletteEntryCount must: be between `1` and |
| sname:VkPhysicalDeviceShadingRateImagePropertiesNV::pname:shadingRatePaletteSize, |
| inclusive |
| |
| **** |
| include::{generated}/validity/structs/VkShadingRatePaletteNV.txt[] |
| -- |
| |
| To determine the base shading rate image, a shading rate index _i_ is mapped |
| to array element _i_ in the array pname:pShadingRatePaletteEntries for the |
| palette corresponding to the viewport used for the fragment. |
| If _i_ is greater than or equal to the palette size |
| pname:shadingRatePaletteEntryCount, the base shading rate is undefined:. |
| |
| [open,refpage='VkShadingRatePaletteEntryNV',desc='Shading rate image palette entry types',type='enums'] |
| -- |
| The supported shading rate image palette entries are defined by |
| elink:VkShadingRatePaletteEntryNV: |
| |
| include::{generated}/api/enums/VkShadingRatePaletteEntryNV.txt[] |
| |
| The following table indicates the width and height (in pixels) of each |
| fragment generated using the indicated shading rate, as well as the maximum |
| number of fragment shader invocations launched for each fragment. |
| When processing regions of a primitive that have a shading rate of |
| ename:VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, no fragments will be |
| generated in that region. |
| |
| [options="header"] |
| |======== |
| | Shading Rate | Width | Height | Invocations |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV | 0 | 0 | 0 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV | 1 | 1 | 16 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV | 1 | 1 | 8 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV | 1 | 1 | 4 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV | 1 | 1 | 2 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV | 1 | 1 | 1 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV | 2 | 1 | 1 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV | 1 | 2 | 1 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV | 2 | 2 | 1 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV | 4 | 2 | 1 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV | 2 | 4 | 1 |
| | ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV | 4 | 4 | 1 |
| |======== |
| -- |
| |
| When the shading rate image is disabled, a shading rate of |
| ename:VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV will be used |
| as the base shading rate. |
| |
| Once a base shading rate has been established, it is adjusted to produce a |
| final shading rate. |
| First, if the base shading rate uses multiple pixels for each fragment, the |
| implementation may: reduce the fragment area to ensure that the total number |
| of coverage samples for all pixels in a fragment does not exceed |
| <<limits-shading-rate-max-coarse-samples, an implementation-dependent |
| maximum>>. |
| |
| If <<primsrast-sampleshading, sample shading>> is active in the current |
| pipeline and would result in processing _n_ (_n_ > 1) unique samples per |
| fragment when the shading rate image is disabled, the shading rate is |
| adjusted in an implementation-dependent manner to increase the number of |
| fragment shader invocations spawned by the primitive. |
| If the shading rate indicates _fs_ pixels per fragment and _fs_ is greater |
| than _n_, the fragment area is adjusted so each fragment has approximately |
| latexmath:[fs \over n] pixels. |
| Otherwise, if the shading rate indicates _ipf_ invocations per fragment, the |
| fragment area will be adjusted to a single pixel with approximately |
| latexmath:[ipf \times n \over fs] invocations per fragment. |
| |
| If sample shading occurs due to the use of a fragment shader input variable |
| decorated with code:SampleId or code:SamplePosition, the shading rate is |
| ignored. |
| Each fragment will have a single pixel and will spawn up to |
| code:totalSamples fragment shader invocations, as when using |
| <<primsrast-sampleshading, sample shading>> without a shading rate image. |
| |
| Finally, if the shading rate specifies multiple fragment shader invocations |
| per fragment, the total number of invocations in the shading rate is clamped |
| to be no larger than the value of code:totalSamples used for |
| <<primsrast-sampleshading, sample shading>>. |
| |
| When the final shading rate for a primitive covering pixel (_x_,_y_) has a |
| fragment area of latexmath:[fw \times fh], the fragment for that pixel will |
| cover all pixels with coordinates (_x_',_y_') that satisfy the equations: |
| |
| [latexmath] |
| +++++++++++++++++++ |
| \begin{aligned} |
| \left\lfloor \frac{x}{fw} \right\rfloor = \left\lfloor \frac{x'}{fw} \right\rfloor |
| \end{aligned} |
| +++++++++++++++++++ |
| [latexmath] |
| +++++++++++++++++++ |
| \begin{aligned} |
| \left\lfloor \frac{y}{fh} \right\rfloor = \left\lfloor \frac{y'}{fh} \right\rfloor |
| \end{aligned} |
| +++++++++++++++++++ |
| |
| This combined fragment is considered to have multiple coverage samples; the |
| total number of samples in this fragment is given by latexmath:[samples = fw |
| \times fh \times rs] where _rs_ indicates the value of |
| sname:VkPipelineMultisampleStateCreateInfo::pname:rasterizationSamples |
| specified at pipeline creation time. |
| The set of coverage samples in the fragment is the union of the per-pixel |
| coverage samples in each of the fragment's pixels The location and order of |
| coverage samples within each pixel in the combined fragment are assigned as |
| described in |
| ifndef::VK_EXT_sample_locations[] |
| <<primsrast-multisampling, Multisampling>>. |
| endif::VK_EXT_sample_locations[] |
| ifdef::VK_EXT_sample_locations[] |
| <<primsrast-multisampling, Multisampling>> and <<primsrast-samplelocations, |
| Custom Sample Locations>>. |
| endif::VK_EXT_sample_locations[] |
| Each coverage sample in the set of pixels belonging to the combined fragment |
| is assigned a unique <<primsrast-multisampling-coverage-mask, coverage |
| index>> in the range [0,_samples_-1]. |
| If the |
| <<features-shadingRateCoarseSampleOrder,shadingRateCoarseSampleOrder>> |
| feature is supported, the order of coverage samples can: be specified for |
| each combination of fragment area and coverage sample count. |
| If this feature is not supported, the sample order is |
| implementation-dependent. |
| |
| [open,refpage='VkPipelineViewportCoarseSampleOrderStateCreateInfoNV',desc='Structure specifying parameters controlling sample order in coarse fragments',type='structs'] |
| -- |
| If the pname:pNext chain of slink:VkPipelineViewportStateCreateInfo includes |
| a sname:VkPipelineViewportCoarseSampleOrderStateCreateInfoNV structure, then |
| that structure includes parameters that control the order of coverage |
| samples in fragments larger than one pixel. |
| |
| The sname:VkPipelineViewportCoarseSampleOrderStateCreateInfoNV structure is |
| defined as: |
| |
| include::{generated}/api/structs/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:sampleOrderType specifies the mechanism used to order coverage |
| samples in fragments larger than one pixel. |
| * pname:customSampleOrderCount specifies the number of custom sample |
| orderings to use when ordering coverage samples. |
| * pname:pCustomSampleOrders is a pointer to an array of |
| pname:customSampleOrderCount slink:VkCoarseSampleOrderCustomNV |
| structures, each of which specifies the coverage sample order for a |
| single combination of fragment area and coverage sample count. |
| |
| If this structure is not present, pname:sampleOrderType is considered to be |
| ename:VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV. |
| |
| If pname:sampleOrderType is ename:VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, the |
| coverage sample order used for any combination of fragment area and coverage |
| sample count not enumerated in pname:pCustomSampleOrders will be identical |
| to that used for ename:VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV. |
| |
| If the pipeline was created with |
| ename:VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, the contents of this |
| structure (if present) are ignored, and the coverage sample order is instead |
| specified by flink:vkCmdSetCoarseSampleOrderNV. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sampleOrderType-02072]] |
| If pname:sampleOrderType is not |
| ename:VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, |
| pname:customSamplerOrderCount must: be `0` |
| * [[VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-pCustomSampleOrders-02234]] |
| The array pname:pCustomSampleOrders must: not contain two structures |
| with matching values for both the pname:shadingRate and |
| pname:sampleCount members |
| **** |
| include::{generated}/validity/structs/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.txt[] |
| -- |
| |
| [open,refpage='VkCoarseSampleOrderTypeNV',desc='Shading rate image sample ordering types',type='enums'] |
| -- |
| The type elink:VkCoarseSampleOrderTypeNV specifies the technique used to |
| order coverage samples in fragments larger than one pixel, and is defined |
| as: |
| |
| include::{generated}/api/enums/VkCoarseSampleOrderTypeNV.txt[] |
| |
| * ename:VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV specifies that coverage |
| samples will be ordered in an implementation-dependent manner. |
| * ename:VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV specifies that coverage |
| samples will be ordered according to the array of custom orderings |
| provided in either the pname:pCustomSampleOrders member of |
| sname:VkPipelineViewportCoarseSampleOrderStateCreateInfoNV or the |
| pname:pCustomSampleOrders member of flink:vkCmdSetCoarseSampleOrderNV. |
| * ename:VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV specifies that coverage |
| samples will be ordered sequentially, sorted first by pixel coordinate |
| (in row-major order) and then by |
| <<primsrast-multisampling-coverage-mask, sample index>>. |
| * ename:VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV specifies that |
| coverage samples will be ordered sequentially, sorted first by |
| <<primsrast-multisampling-coverage-mask, sample index>> and then by |
| pixel coordinate (in row-major order). |
| |
| -- |
| |
| When using a coarse sample order of |
| ename:VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV for a fragment with an |
| upper-left corner of latexmath:[(fx,fy)] with a width of latexmath:[fw |
| \times fh] and latexmath:[fsc] samples per pixel, |
| <<primsrast-multisampling-coverage-mask, coverage index>> latexmath:[cs] of |
| the fragment will be assigned to <<primsrast-multisampling-coverage-mask, |
| sample index>> latexmath:[fs] of pixel latexmath:[(px,py)] as follows: |
| |
| [latexmath] |
| +++++++++++++++++++ |
| \begin{aligned} |
| px = & fx + (\left\lfloor {cs \over fsc} \right\rfloor \text{ \% } fw) \\ |
| py = & fy + \left\lfloor {cs \over {fsc \times fw}} \right\rfloor \\ |
| fs = & cs \text{ \% } fsc |
| \end{aligned} |
| +++++++++++++++++++ |
| |
| When using a coarse sample order of |
| ename:VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV, |
| <<primsrast-multisampling-coverage-mask, coverage index>> latexmath:[cs] |
| will be assigned as follows: |
| |
| [latexmath] |
| +++++++++++++++++++ |
| \begin{aligned} |
| px = & fx + cs \text{ \% } fw \\ |
| py = & (fy + \left\lfloor {cs \over fw} \right\rfloor \text{ \% } fh) \\ |
| fs = & \left\lfloor {cs \over {fw \times fh}} \right\rfloor |
| \end{aligned} |
| +++++++++++++++++++ |
| |
| [open,refpage='VkCoarseSampleOrderCustomNV',desc='Structure specifying parameters controlling shading rate image usage',type='structs'] |
| -- |
| The sname:VkCoarseSampleOrderCustomNV structure is used with a coverage |
| sample ordering type of ename:VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV to |
| specify the order of coverage samples for one combination of fragment width, |
| fragment height, and coverage sample count. |
| The structure is defined as: |
| |
| include::{generated}/api/structs/VkCoarseSampleOrderCustomNV.txt[] |
| |
| * pname:shadingRate is a shading rate palette entry that identifies the |
| fragment width and height for the combination of fragment area and |
| per-pixel coverage sample count to control. |
| * pname:sampleCount identifies the per-pixel coverage sample count for the |
| combination of fragment area and coverage sample count to control. |
| * pname:sampleLocationCount specifies the number of sample locations in |
| the custom ordering. |
| * pname:pSampleLocations is a pointer to an array of |
| slink:VkCoarseSampleLocationNV structures specifying the location of |
| each sample in the custom ordering. |
| |
| When using a custom sample ordering, element _j_ in pname:pSampleLocations |
| specifies a specific pixel location and |
| <<primsrast-multisampling-coverage-mask, sample index>> that corresponds to |
| <<primsrast-multisampling-coverage-mask, coverage index>> _j_ in the |
| multi-pixel fragment. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkCoarseSampleOrderCustomNV-shadingRate-02073]] |
| pname:shadingRate must: be a shading rate that generates fragments with |
| more than one pixel |
| * [[VUID-VkCoarseSampleOrderCustomNV-sampleCount-02074]] |
| pname:sampleCount must: correspond to a sample count enumerated in |
| tlink:VkSampleCountFlags whose corresponding bit is set in |
| slink:VkPhysicalDeviceLimits::pname:framebufferNoAttachmentsSampleCounts |
| * [[VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02075]] |
| pname:sampleLocationCount must: be equal to the product of |
| pname:sampleCount, the fragment width for pname:shadingRate, and the |
| fragment height for pname:shadingRate |
| * [[VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02076]] |
| pname:sampleLocationCount must: be less than or equal to the value of |
| sname:VkPhysicalDeviceShadingRateImagePropertiesNV::pname:shadingRateMaxCoarseSamples |
| * [[VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-02077]] |
| The array pname:pSampleLocations must: contain exactly one entry for |
| every combination of valid values for pname:pixelX, pname:pixelY, and |
| pname:sample in the structure slink:VkCoarseSampleOrderCustomNV |
| **** |
| include::{generated}/validity/structs/VkCoarseSampleOrderCustomNV.txt[] |
| -- |
| |
| [open,refpage='VkCoarseSampleLocationNV',desc='Structure specifying parameters controlling shading rate image usage',type='structs'] |
| -- |
| The sname:VkCoarseSampleLocationNV structure identifies a specific pixel and |
| <<primsrast-multisampling-coverage-mask, sample index>> for one of the |
| coverage samples in a fragment that is larger than one pixel. |
| This structure is defined as: |
| |
| include::{generated}/api/structs/VkCoarseSampleLocationNV.txt[] |
| |
| * pname:pixelX is added to the x coordinate of the upper-leftmost pixel of |
| each fragment to identify the pixel containing the coverage sample. |
| * pname:pixelY is added to the y coordinate of the upper-leftmost pixel of |
| each fragment to identify the pixel containing the coverage sample. |
| * pname:sample is the number of the coverage sample in the pixel |
| identified by pname:pixelX and pname:pixelY. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkCoarseSampleLocationNV-pixelX-02078]] |
| pname:pixelX must: be less than the width (in pixels) of the fragment |
| * [[VUID-VkCoarseSampleLocationNV-pixelY-02079]] |
| pname:pixelY must: be less than the height (in pixels) of the fragment |
| * [[VUID-VkCoarseSampleLocationNV-sample-02080]] |
| pname:sample must: be less than the number of coverage samples in each |
| pixel belonging to the fragment |
| **** |
| |
| include::{generated}/validity/structs/VkCoarseSampleLocationNV.txt[] |
| -- |
| |
| [open,refpage='vkCmdSetCoarseSampleOrderNV',desc='Set order of coverage samples for coarse fragments dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the order of coverage |
| samples in fragments larger than one pixel, call: |
| |
| include::{generated}/api/protos/vkCmdSetCoarseSampleOrderNV.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:sampleOrderType specifies the mechanism used to order coverage |
| samples in fragments larger than one pixel. |
| * pname:customSampleOrderCount specifies the number of custom sample |
| orderings to use when ordering coverage samples. |
| * pname:pCustomSampleOrders is a pointer to an array of |
| slink:VkCoarseSampleOrderCustomNV structures, each of which specifies |
| the coverage sample order for a single combination of fragment area and |
| coverage sample count. |
| |
| If pname:sampleOrderType is ename:VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, the |
| coverage sample order used for any combination of fragment area and coverage |
| sample count not enumerated in pname:pCustomSampleOrders will be identical |
| to that used for ename:VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV. |
| |
| This command sets the order of coverage samples for subsequent drawing |
| commands when the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineViewportCoarseSampleOrderStateCreateInfoNV values used to |
| create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetCoarseSampleOrderNV-sampleOrderType-02081]] |
| If pname:sampleOrderType is not |
| ename:VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, |
| pname:customSamplerOrderCount must: be `0` |
| * [[VUID-vkCmdSetCoarseSampleOrderNV-pCustomSampleOrders-02235]] |
| The array pname:pCustomSampleOrders must: not contain two structures |
| with matching values for both the pname:shadingRate and |
| pname:sampleCount members |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetCoarseSampleOrderNV.txt[] |
| -- |
| |
| If the final shading rate for a primitive covering pixel (_x_,_y_) results |
| in _n_ invocations per pixel (_n_ > 1), _n_ separate fragment shader |
| invocations will be generated for the fragment. |
| Each coverage sample in the fragment will be assigned to one of the _n_ |
| fragment shader invocations in an implementation-dependent manner. |
| The outputs from the <<interfaces-fragmentoutput, fragment output |
| interface>> of each shader invocation will be broadcast to all of the |
| framebuffer samples associated with the invocation. |
| If none of the coverage samples associated with a fragment shader invocation |
| is covered by a primitive, the implementation may: discard the fragment |
| shader invocation for those samples. |
| |
| If the final shading rate for a primitive covering pixel (_x_,_y_) results |
| in a fragment containing multiple pixels, a single set of fragment shader |
| invocations will be generated for all pixels in the combined fragment. |
| Outputs from the <<interfaces-fragmentoutput, fragment output interface>> |
| will be broadcast to all covered framebuffer samples belonging to the |
| fragment. |
| If the fragment shader executes code discarding the fragment, none of the |
| samples of the fragment will be updated. |
| |
| endif::VK_NV_shading_rate_image[] |
| |
| |
| [[primsrast-sampleshading]] |
| == Sample Shading |
| |
| Sample shading can: be used to specify a minimum number of unique samples to |
| process for each fragment. |
| If sample shading is enabled an implementation must: provide a minimum of |
| [eq]#max({lceil} pname:minSampleShadingFactor {times} pname:totalSamples |
| {rceil}, 1)# unique associated data for each fragment, where |
| pname:minSampleShadingFactor is the minimum fraction of sample shading. |
| ifdef::VK_AMD_mixed_attachment_samples[] |
| If the `apiext:VK_AMD_mixed_attachment_samples` extension is enabled and the |
| subpass uses color attachments, pname:totalSamples is the number of samples |
| of the color attachments. |
| Otherwise, |
| endif::VK_AMD_mixed_attachment_samples[] |
| pname:totalSamples is the value of |
| slink:VkPipelineMultisampleStateCreateInfo::pname:rasterizationSamples |
| specified at pipeline creation time. |
| These are associated with the samples in an implementation-dependent manner. |
| When pname:minSampleShadingFactor is `1.0`, a separate set of associated |
| data are evaluated for each sample, and each set of values is evaluated at |
| the sample location. |
| |
| Sample shading is enabled for a graphics pipeline: |
| |
| * If the interface of the fragment shader entry point of the graphics |
| pipeline includes an input variable decorated with code:SampleId or |
| code:SamplePosition. |
| In this case pname:minSampleShadingFactor takes the value `1.0`. |
| * Else if the pname:sampleShadingEnable member of the |
| slink:VkPipelineMultisampleStateCreateInfo structure specified when |
| creating the graphics pipeline is set to ename:VK_TRUE. |
| In this case pname:minSampleShadingFactor takes the value of |
| slink:VkPipelineMultisampleStateCreateInfo::pname:minSampleShading. |
| |
| Otherwise, sample shading is considered disabled. |
| |
| |
| ifdef::VK_NV_fragment_shader_barycentric[] |
| [[primsrast-barycentric]] |
| == Barycentric Interpolation |
| |
| When the pname:fragmentShaderBarycentric feature is enabled, the |
| code:PerVertexNV <<shaders-interpolation-decorations, interpolation |
| decoration>> can: be used with fragment shader inputs to indicate that the |
| decorated inputs do not have associated data in the fragment. |
| Such inputs can: only be accessed in a fragment shader using an array index |
| whose value (0, 1, or 2) identifies one of the vertices of the primitive |
| that produced the fragment. |
| |
| ifndef::VK_NV_mesh_shader[] |
| When <<tessellation, tessellation>> and <<geometry, geometry shading>> |
| endif::VK_NV_mesh_shader[] |
| ifdef::VK_NV_mesh_shader[] |
| When <<tessellation, tessellation>>, <<geometry, geometry shading>>, and |
| <<mesh,mesh shading>> |
| endif::VK_NV_mesh_shader[] |
| are not active, fragment shader inputs decorated with code:PerVertexNV will |
| take values from one of the vertices of the primitive that produced the |
| fragment, identified by the extra index provided in SPIR-V code accessing |
| the input. |
| If the _n_ vertices passed to a draw call are numbered 0 through _n_-1, and |
| the point, line, and triangle primitives produced by the draw call are |
| numbered with consecutive integers beginning with zero, the following table |
| indicates the original vertex numbers used |
| ifdef::VK_EXT_provoking_vertex[] |
| when the <<vertexpostproc-flatshading,provoking vertex mode>> is |
| ename:VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT |
| endif::VK_EXT_provoking_vertex[] |
| for index values of 0, 1, and 2. |
| If an input decorated with code:PerVertexNV is accessed with any other |
| vertex index value, an undefined: value is returned. |
| |
| [[primsrast-barycentric-order-table]] |
| [options="header"] |
| |====== |
| | Primitive Topology | Vertex 0 | Vertex 1 | Vertex 2 |
| | ename:VK_PRIMITIVE_TOPOLOGY_POINT_LIST | i | - | - |
| | ename:VK_PRIMITIVE_TOPOLOGY_LINE_LIST | 2i | 2i+1 | - |
| | ename:VK_PRIMITIVE_TOPOLOGY_LINE_STRIP | i | i+1 | - |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST | 3i | 3i+1 | 3i+2 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP (even) | i | i+1 | i+2 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP (odd) | i | i+2 | i+1 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN | i+1 | i+2 | 0 |
| | ename:VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY | 4i+1 | 4i+2 | - |
| | ename:VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY | i+1 | i+2 | - |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY | 6i | 6i+2 | 6i+4 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY (even) | 2i | 2i+2 | 2i+4 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY (odd) | 2i | 2i+4 | 2i+2 |
| |====== |
| |
| ifdef::VK_EXT_provoking_vertex[] |
| When the provoking vertex mode is |
| ename:VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT, the original vertex numbers |
| used are the same as above except as indicated in the table below. |
| |
| [[primsrast-barycentric-order-table-last-vertex]] |
| [options="header"] |
| |====== |
| | Primitive Topology | Vertex 0 | Vertex 1 | Vertex 2 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP (odd) | i+1 | i | i+2 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN | 0 | i+1 | i+2 |
| | ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY (odd) | 2i+2 | 2i | 2i+4 |
| |====== |
| endif::VK_EXT_provoking_vertex[] |
| |
| When geometry |
| ifdef::VK_NV_mesh_shader[] |
| or mesh |
| endif::VK_NV_mesh_shader[] |
| shading is active, primitives processed by fragment shaders are assembled |
| from the vertices emitted by the geometry |
| ifdef::VK_NV_mesh_shader[] |
| or mesh |
| endif::VK_NV_mesh_shader[] |
| shader. |
| In this case, the vertices used for fragment shader inputs decorated with |
| code:PerVertexNV are derived by treating the primitives produced by the |
| shader as though they were specified by a draw call and consulting |
| <<primsrast-barycentric-order-table, the table above>>. |
| |
| When using tessellation without geometry shading, the tessellator produces |
| primitives in an implementation-dependent manner. |
| While there is no defined vertex ordering for inputs decorated with |
| code:PerVertexNV, the vertex ordering used in this case will be consistent |
| with the ordering used to derive the values of inputs decorated with |
| code:BaryCoordNV or code:BaryCoordNoPerspNV. |
| |
| Fragment shader inputs decorated with code:BaryCoordNV or |
| code:BaryCoordNoPerspNV hold three-component vectors with barycentric |
| weights that indicate the location of the fragment relative to the |
| screen-space locations of vertices of its primitive. |
| For point primitives, such variables are always assigned the value (1,0,0). |
| For <<primsrast-lines-basic, line>> primitives, the built-ins are obtained |
| by interpolating an attribute whose values for the vertices numbered 0 and 1 |
| are (1,0,0) and (0,1,0), respectively. |
| For <<primsrast-polygons-basic, polygon>> primitives, the built-ins are |
| obtained by interpolating an attribute whose values for the vertices |
| numbered 0, 1, and 2 are (1,0,0), (0,1,0), and (0,0,1), respectively. |
| For code:BaryCoordNV, the values are obtained using perspective |
| interpolation. |
| For code:BaryCoordNoPerspNV, the values are obtained using linear |
| interpolation. |
| |
| endif::VK_NV_fragment_shader_barycentric[] |
| |
| |
| [[primsrast-points]] |
| == Points |
| |
| A point is drawn by generating a set of fragments in the shape of a square |
| centered around the vertex of the point. |
| Each vertex has an associated point size that controls the width/height of |
| that square. |
| The point size is taken from the (potentially clipped) shader built-in |
| code:PointSize written by: |
| |
| * the geometry shader, if active; |
| * the tessellation evaluation shader, if active and no geometry shader is |
| active; |
| * the vertex shader, otherwise |
| |
| and clamped to the implementation-dependent point size range |
| [eq]#[pname:pointSizeRange[0],pname:pointSizeRange[1]]#. |
| The value written to code:PointSize must: be greater than zero. |
| |
| Not all point sizes need be supported, but the size 1.0 must: be supported. |
| The range of supported sizes and the size of evenly-spaced gradations within |
| that range are implementation-dependent. |
| The range and gradations are obtained from the pname:pointSizeRange and |
| pname:pointSizeGranularity members of slink:VkPhysicalDeviceLimits. |
| If, for instance, the size range is from 0.1 to 2.0 and the gradation size |
| is 0.1, then the sizes 0.1, 0.2, ..., 1.9, 2.0 are supported. |
| Additional point sizes may: also be supported. |
| There is no requirement that these sizes be equally spaced. |
| If an unsupported size is requested, the nearest supported size is used |
| instead. |
| |
| ifdef::VK_EXT_fragment_density_map[] |
| Further, if the render pass has a fragment density map attachment, point |
| size may: be rounded by the implementation to a multiple of the fragment's |
| width or height. |
| endif::VK_EXT_fragment_density_map[] |
| |
| |
| [[primsrast-points-basic]] |
| === Basic Point Rasterization |
| |
| Point rasterization produces a fragment for each fragment area group of |
| framebuffer pixels with one or more sample points that intersect a region |
| centered at the point's [eq]#(x~f~,y~f~)#. |
| This region is a square with side equal to the current point size. |
| Coverage bits that correspond to sample points that intersect the region are |
| 1, other coverage bits are 0. |
| All fragments produced in rasterizing a point are assigned the same |
| associated data, which are those of the vertex corresponding to the point. |
| However, the fragment shader built-in code:PointCoord contains point sprite |
| texture coordinates. |
| The [eq]#s# and [eq]#t# point sprite texture coordinates vary from zero to |
| one across the point horizontally left-to-right and vertically |
| top-to-bottom, respectively. |
| The following formulas are used to evaluate [eq]#s# and [eq]#t#: |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| s = {1 \over 2} + { \left( x_p - x_f \right) \over \text{size} } |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| t = {1 \over 2} + { \left( y_p - y_f \right) \over \text{size} } |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| where size is the point's size; [eq]#(x~p~,y~p~)# is the location at which |
| the point sprite coordinates are evaluated - this may: be the framebuffer |
| coordinates of the fragment center, or the location of a sample; and |
| [eq]#(x~f~,y~f~)# is the exact, unrounded framebuffer coordinate of the |
| vertex for the point. |
| |
| |
| [[primsrast-lines]] |
| == Line Segments |
| |
| ifdef::VK_EXT_line_rasterization[] |
| [open,refpage='VkPipelineRasterizationLineStateCreateInfoEXT',desc='Structure specifying parameters of a newly created pipeline line rasterization state',type='structs'] |
| -- |
| Line segment rasterization options are controlled by the |
| slink:VkPipelineRasterizationLineStateCreateInfoEXT structure. |
| |
| The sname:VkPipelineRasterizationLineStateCreateInfoEXT structure is defined |
| as: |
| |
| include::{generated}/api/structs/VkPipelineRasterizationLineStateCreateInfoEXT.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:lineRasterizationMode is a elink:VkLineRasterizationModeEXT value |
| selecting the style of line rasterization. |
| * pname:stippledLineEnable enables <<primsrast-lines-stipple, stippled |
| line rasterization>>. |
| * pname:lineStippleFactor is the repeat factor used in stippled line |
| rasterization. |
| * pname:lineStipplePattern is the bit pattern used in stippled line |
| rasterization. |
| |
| If pname:stippledLineEnable is ename:VK_FALSE, the values of |
| pname:lineStippleFactor and pname:lineStipplePattern are ignored. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768]] |
| If pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the |
| <<features-rectangularLines,rectangularLines>> feature must: be enabled |
| * [[VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769]] |
| If pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the |
| <<features-bresenhamLines,bresenhamLines>> feature must: be enabled |
| * [[VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770]] |
| If pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the |
| <<features-bresenhamLines,smoothLines>> feature must: be enabled |
| * [[VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771]] |
| If pname:stippledLineEnable is ename:VK_TRUE and |
| pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the |
| <<features-stippledRectangularLines,stippledRectangularLines>> feature |
| must: be enabled |
| * [[VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772]] |
| If pname:stippledLineEnable is ename:VK_TRUE and |
| pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the |
| <<features-stippledBresenhamLines,stippledBresenhamLines>> feature must: |
| be enabled |
| * [[VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773]] |
| If pname:stippledLineEnable is ename:VK_TRUE and |
| pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the |
| <<features-stippledSmoothLines,stippledSmoothLines>> feature must: be |
| enabled |
| * [[VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774]] |
| If pname:stippledLineEnable is ename:VK_TRUE and |
| pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the |
| <<features-stippledRectangularLines,stippledRectangularLines>> feature |
| must: be enabled and slink:VkPhysicalDeviceLimits::pname:strictLines |
| must: be ename:VK_TRUE |
| **** |
| |
| include::{generated}/validity/structs/VkPipelineRasterizationLineStateCreateInfoEXT.txt[] |
| -- |
| |
| [open,refpage='VkLineRasterizationModeEXT',desc='Line rasterization modes',type='enums'] |
| -- |
| Possible values of |
| slink:VkPipelineRasterizationLineStateCreateInfoEXT::pname:lineRasterizationMode |
| are: |
| |
| include::{generated}/api/enums/VkLineRasterizationModeEXT.txt[] |
| |
| * ename:VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT is equivalent to |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT if |
| slink:VkPhysicalDeviceLimits::pname:strictLines is ename:VK_TRUE, |
| otherwise lines are drawn as non-pname:strictLines parallelograms. |
| Both of these modes are defined in <<primsrast-lines-basic,Basic Line |
| Segment Rasterization>>. |
| * ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT specifies lines drawn |
| as if they were rectangles extruded from the line |
| * ename:VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT specifies lines drawn by |
| determining which pixel diamonds the line intersects and exits, as |
| defined in <<primsrast-lines-bresenham,Bresenham Line Segment |
| Rasterization>>. |
| * ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT specifies lines |
| drawn if they were rectangles extruded from the line, with alpha |
| falloff, as defined in <<primsrast-lines-smooth,Smooth Lines>>. |
| -- |
| endif::VK_EXT_line_rasterization[] |
| |
| [open,refpage='vkCmdSetLineWidth',desc='Set line width dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the line width, call: |
| |
| include::{generated}/api/protos/vkCmdSetLineWidth.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:lineWidth is the width of rasterized line segments. |
| |
| This command sets the line width for subsequent drawing commands when the |
| graphics pipeline is created with ename:VK_DYNAMIC_STATE_LINE_WIDTH set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineRasterizationStateCreateInfo::pname:lineWidth value used to |
| create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetLineWidth-lineWidth-00788]] |
| If the <<features-wideLines,wide lines>> feature is not enabled, |
| pname:lineWidth must: be `1.0` |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetLineWidth.txt[] |
| -- |
| |
| Not all line widths need be supported for line segment rasterization, but |
| width 1.0 antialiased segments must: be provided. |
| The range and gradations are obtained from the pname:lineWidthRange and |
| pname:lineWidthGranularity members of slink:VkPhysicalDeviceLimits. |
| If, for instance, the size range is from 0.1 to 2.0 and the gradation size |
| is 0.1, then the sizes 0.1, 0.2, ..., 1.9, 2.0 are supported. |
| Additional line widths may: also be supported. |
| There is no requirement that these widths be equally spaced. |
| If an unsupported width is requested, the nearest supported width is used |
| instead. |
| |
| ifdef::VK_EXT_fragment_density_map[] |
| Further, if the render pass has a fragment density map attachment, line |
| width may: be rounded by the implementation to a multiple of the fragment's |
| width or height. |
| endif::VK_EXT_fragment_density_map[] |
| |
| |
| [[primsrast-lines-basic]] |
| === Basic Line Segment Rasterization |
| |
| ifdef::VK_EXT_line_rasterization[] |
| If the pname:lineRasterizationMode member of |
| slink:VkPipelineRasterizationLineStateCreateInfoEXT is |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, rasterized |
| endif::VK_EXT_line_rasterization[] |
| ifndef::VK_EXT_line_rasterization[] |
| Rasterized |
| endif::VK_EXT_line_rasterization[] |
| line segments produce fragments which intersect a rectangle centered on the |
| line segment. |
| Two of the edges are parallel to the specified line segment; each is at a |
| distance of one-half the current width from that segment in directions |
| perpendicular to the direction of the line. |
| The other two edges pass through the line endpoints and are perpendicular to |
| the direction of the specified line segment. |
| Coverage bits that correspond to sample points that intersect the rectangle |
| are 1, other coverage bits are 0. |
| |
| Next we specify how the data associated with each rasterized fragment are |
| obtained. |
| Let [eq]#**p**~r~ = (x~d~, y~d~)# be the framebuffer coordinates at which |
| associated data are evaluated. |
| This may: be the center of a fragment or the location of a sample within the |
| fragment. |
| When pname:rasterizationSamples is ename:VK_SAMPLE_COUNT_1_BIT, the fragment |
| center must: be used. |
| Let [eq]#**p**~a~ = (x~a~, y~a~)# and [eq]#**p**~b~ = (x~b~,y~b~)# be |
| initial and final endpoints of the line segment, respectively. |
| Set |
| |
| // Equation {linet:eq} |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| t = {{( \mathbf{p}_r - \mathbf{p}_a ) \cdot ( \mathbf{p}_b - \mathbf{p}_a )} |
| \over {\| \mathbf{p}_b - \mathbf{p}_a \|^2 }} |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| (Note that [eq]#t = 0# at [eq]#**p**~a~# and [eq]#t = 1# at [eq]#**p**~b~#. |
| Also note that this calculation projects the vector from [eq]#**p**~a~# to |
| [eq]#**p**~r~# onto the line, and thus computes the normalized distance of |
| the fragment along the line.) |
| |
| [[line_perspective_interpolation]] |
| The value of an associated datum [eq]#f# for the fragment, whether it be a |
| shader output or the clip [eq]#w# coordinate, must: be determined using |
| _perspective interpolation_: |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| f = {{ (1-t) {f_a / w_a} + t { f_b / w_b} } \over |
| {(1-t) / w_a + t / w_b }} |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| where [eq]#f~a~# and [eq]#f~b~# are the data associated with the starting |
| and ending endpoints of the segment, respectively; [eq]#w~a~# and [eq]#w~b~# |
| are the clip [eq]#w# coordinates of the starting and ending endpoints of the |
| segment, respectively. |
| |
| [[line_linear_interpolation]] |
| Depth values for lines must: be determined using _linear interpolation_: |
| |
| {empty}:: [eq]#z = (1 - t) z~a~ {plus} t z~b~# |
| |
| where [eq]#z~a~# and [eq]#z~b~# are the depth values of the starting and |
| ending endpoints of the segment, respectively. |
| |
| The code:NoPerspective and code:Flat |
| <<shaders-interpolation-decorations,interpolation decorations>> can: be used |
| with fragment shader inputs to declare how they are interpolated. |
| When neither decoration is applied, <<line_perspective_interpolation, |
| perspective interpolation>> is performed as described above. |
| When the code:NoPerspective decoration is used, <<line_linear_interpolation, |
| linear interpolation>> is performed in the same fashion as for depth values, |
| as described above. |
| When the code:Flat decoration is used, no interpolation is performed, and |
| outputs are taken from the corresponding input value of the |
| <<vertexpostproc-flatshading,provoking vertex>> corresponding to that |
| primitive. |
| |
| ifdef::VK_NV_fragment_shader_barycentric[] |
| When the pname:fragmentShaderBarycentric feature is enabled, the |
| code:PerVertexNV <<shaders-interpolation-decorations, interpolation |
| decoration>> can: also be used with fragment shader inputs which indicate |
| that the decorated inputs are not interpolated and can: only be accessed |
| using an extra array dimension, where the extra index identifies one of the |
| vertices of the primitive that produced the fragment. |
| endif::VK_NV_fragment_shader_barycentric[] |
| |
| The above description documents the preferred method of line rasterization, |
| and must: be used when the implementation advertises the pname:strictLines |
| limit in slink:VkPhysicalDeviceLimits as ename:VK_TRUE. |
| |
| When pname:strictLines is ename:VK_FALSE, the edges of the lines are |
| generated as a parallelogram surrounding the original line. |
| The major axis is chosen by noting the axis in which there is the greatest |
| distance between the line start and end points. |
| If the difference is equal in both directions then the X axis is chosen as |
| the major axis. |
| Edges 2 and 3 are aligned to the minor axis and are centered on the |
| endpoints of the line as in <<fig-non-strict-lines>>, and each is |
| pname:lineWidth long. |
| Edges 0 and 1 are parallel to the line and connect the endpoints of edges 2 |
| and 3. |
| Coverage bits that correspond to sample points that intersect the |
| parallelogram are 1, other coverage bits are 0. |
| |
| Samples that fall exactly on the edge of the parallelogram follow the |
| polygon rasterization rules. |
| |
| Interpolation occurs as if the parallelogram was decomposed into two |
| triangles where each pair of vertices at each end of the line has identical |
| attributes. |
| |
| [[fig-non-strict-lines]] |
| image::{images}/non_strict_lines.svg[align="center",title="Non strict lines",opts="{imageopts}"] |
| |
| Only when pname:strictLines is ename:VK_FALSE implementations may: deviate |
| from the non-strict line algorithm described above in the following ways: |
| |
| * Implementations may: instead interpolate each fragment according to the |
| formula in <<primsrast-lines-basic, Basic Line Segment Rasterization>> |
| using the original line segment endpoints. |
| |
| * Rasterization of non-antialiased non-strict line segments may: be |
| performed using the rules defined in |
| <<primsrast-lines-bresenham,Bresenham Line Segment Rasterization>>. |
| |
| |
| [[primsrast-lines-bresenham]] |
| === Bresenham Line Segment Rasterization |
| |
| ifdef::VK_EXT_line_rasterization[] |
| If pname:lineRasterizationMode is |
| ename:VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the following rules |
| replace the line rasterization rules defined in <<primsrast-lines-basic, |
| Basic Line Segment Rasterization>>. |
| endif::VK_EXT_line_rasterization[] |
| |
| Non-strict lines may: also follow these rasterization rules for |
| non-antialiased lines. |
| |
| Line segment rasterization begins by characterizing the segment as either |
| _x-major_ or _y-major_. |
| x-major line segments have slope in the closed interval [eq]#[-1,1]#; all |
| other line segments are y-major (slope is determined by the segment's |
| endpoints). |
| We specify rasterization only for x-major segments except in cases where the |
| modifications for y-major segments are not self-evident. |
| |
| Ideally, Vulkan uses a _diamond-exit_ rule to determine those fragments that |
| are produced by rasterizing a line segment. |
| For each fragment [eq]#f# with center at framebuffer coordinates [eq]#x~f~# |
| and [eq]#y~f~#, define a diamond-shaped region that is the intersection of |
| four half planes: |
| |
| [latexmath] |
| +++++++++++++++++++ |
| R_f = \{ (x,y) \mid | x - x_f | + | y - y_f | < \frac{1}{2} \} |
| +++++++++++++++++++ |
| |
| Essentially, a line segment starting at [eq]#p~a~# and ending at [eq]#p~b~# |
| produces those fragments [eq]#f# for which the segment intersects |
| [eq]#R~f~#, except if [eq]#p~b~# is contained in [eq]#R~f~#. |
| |
| image::{images}/bresenham.svg[title="Visualization of Bresenham's algorithm",align="center",opts="{imageopts}"] |
| |
| To avoid difficulties when an endpoint lies on a boundary of [eq]#R~f~# we |
| (in principle) perturb the supplied endpoints by a tiny amount. |
| Let [eq]#p~a~# and [eq]#p~b~# have framebuffer coordinates [eq]#(x~a~, |
| y~a~)# and [eq]#(x~b~, y~b~)#, respectively. |
| Obtain the perturbed endpoints [eq]#p~a~'# given by [eq]#(x~a~, y~a~) - |
| ({epsilon}, {epsilon}^2^)# and [eq]#p~b~'# given by [eq]#(x~b~, y~b~) - |
| ({epsilon}, {epsilon}^2^)#. |
| Rasterizing the line segment starting at [eq]#p~a~# and ending at [eq]#p~b~# |
| produces those fragments [eq]#f# for which the segment starting at |
| [eq]#p~a~'# and ending on [eq]#p~b~'# intersects [eq]#R~f~#, except if |
| [eq]#p~b~'# is contained in [eq]#R~f~#. |
| [eq]#{epsilon}# is chosen to be so small that rasterizing the line segment |
| produces the same fragments when [eq]#{delta}# is substituted for |
| [eq]#{epsilon}# for any [eq]#0 < {delta} {leq} {epsilon}#. |
| |
| When [eq]#p~a~# and [eq]#p~b~# lie on fragment centers, this |
| characterization of fragments reduces to Bresenham's algorithm with one |
| modification: lines produced in this description are "half-open," meaning |
| that the final fragment (corresponding to [eq]#p~b~#) is not drawn. |
| This means that when rasterizing a series of connected line segments, shared |
| endpoints will be produced only once rather than twice (as would occur with |
| Bresenham's algorithm). |
| |
| Implementations may: use other line segment rasterization algorithms, |
| subject to the following rules: |
| |
| * The coordinates of a fragment produced by the algorithm must: not |
| deviate by more than one unit in either x or y framebuffer coordinates |
| from a corresponding fragment produced by the diamond-exit rule. |
| * The total number of fragments produced by the algorithm must: not differ |
| from that produced by the diamond-exit rule by no more than one. |
| * For an x-major line, two fragments that lie in the same |
| framebuffer-coordinate column must: not be produced (for a y-major line, |
| two fragments that lie in the same framebuffer-coordinate row must: not |
| be produced). |
| * If two line segments share a common endpoint, and both segments are |
| either x-major (both left-to-right or both right-to-left) or y-major |
| (both bottom-to-top or both top-to-bottom), then rasterizing both |
| segments must: not produce duplicate fragments. |
| Fragments also must: not be omitted so as to interrupt continuity of the |
| connected segments. |
| |
| The actual width [eq]#w# of Bresenham lines is determined by rounding the |
| line width to the nearest integer, clamping it to the |
| implementation-dependent pname:lineWidthRange (with both values rounded to |
| the nearest integer), then clamping it to be no less than 1. |
| |
| Bresenham line segments of width other than one are rasterized by offsetting |
| them in the minor direction (for an x-major line, the minor direction is y, |
| and for a y-major line, the minor direction is x) and producing a row or |
| column of fragments in the minor direction. |
| If the line segment has endpoints given by [eq]#(x~0~, y~0~)# and |
| [eq]#(x~1~, y~1~)# in framebuffer coordinates, the segment with endpoints |
| latexmath:[(x_0, y_0 - \frac{w-1}{2})] and latexmath:[(x_1, y_1 - |
| \frac{w-1}{2})] is rasterized, but instead of a single fragment, a column of |
| fragments of height w (a row of fragments of length w for a y-major segment) |
| is produced at each x (y for y-major) location. |
| The lowest fragment of this column is the fragment that would be produced by |
| rasterizing the segment of width 1 with the modified coordinates. |
| |
| The preferred method of attribute interpolation for a wide line is to |
| generate the same attribute values for all fragments in the row or column |
| described above, as if the adjusted line was used for interpolation and |
| those values replicated to the other fragments, except for code:FragCoord |
| which is interpolated as usual. |
| Implementations may: instead interpolate each fragment according to the |
| formula in <<primsrast-lines-basic,Basic Line Segment Rasterization>>, using |
| the original line segment endpoints. |
| |
| When Bresenham lines are being rasterized, sample locations may: all be |
| treated as being at the pixel center (this may: affect attribute and depth |
| interpolation). |
| |
| [NOTE] |
| .Note |
| ==== |
| The sample locations described above are *not* used for determining |
| coverage, they are only used for things like attribute interpolation. |
| The rasterization rules that determine coverage are defined in terms of |
| whether the line intersects *pixels*, as opposed to the point sampling rules |
| used for other primitive types. |
| So these rules are independent of the sample locations. |
| One consequence of this is that Bresenham lines cover the same pixels |
| regardless of the number of rasterization samples, and cover all samples in |
| those pixels (unless masked out or killed). |
| ==== |
| |
| |
| ifdef::VK_EXT_line_rasterization[] |
| [[primsrast-lines-stipple]] |
| === Line Stipple |
| |
| If the pname:stippledLineEnable member of |
| slink:VkPipelineRasterizationLineStateCreateInfoEXT is ename:VK_TRUE, then |
| lines are rasterized with a _line stipple_ determined by |
| pname:lineStippleFactor and pname:lineStipplePattern. |
| pname:lineStipplePattern is an unsigned 16-bit integer that determines which |
| fragments are to be drawn or discarded when the line is rasterized. |
| pname:lineStippleFactor is a count that is used to modify the effective line |
| stipple by causing each bit in pname:lineStipplePattern to be used |
| pname:lineStippleFactor times. |
| |
| Line stippling discards certain fragments that are produced by |
| rasterization. |
| The masking is achieved using three parameters: the 16-bit line stipple |
| pattern _p_, the line stipple factor _r_, and an integer stipple counter |
| _s_. |
| Let |
| |
| [latexmath] |
| +++++++++++++++++++ |
| b = \left\lfloor \frac{s}{r} \right\rfloor \bmod 16 |
| +++++++++++++++++++ |
| |
| Then a fragment is produced if the _b_'th bit of _p_ is 1, and discarded |
| otherwise. |
| The bits of _p_ are numbered with 0 being the least significant and 15 being |
| the most significant. |
| |
| The initial value of _s_ is zero. |
| For ename:VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT lines, _s_ is incremented |
| after production of each fragment of a line segment (fragments are produced |
| in order, beginning at the starting point and working towards the ending |
| point). |
| For ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT and |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT lines, the |
| rectangular region is subdivided into adjacent unit-length rectangles, and s |
| is incremented once for each rectangle. |
| Rectangles with a value of _s_ such that the _b_'th bit of _p_ is zero are |
| discarded. |
| If the last rectangle in a line segment is shorter than unit-length, then |
| the remainder may: carry over to the next line segment in the line strip |
| using the same value of _s_ (this is the preferred behavior, for the stipple |
| pattern to appear more consistent through the strip). |
| |
| _s_ is reset to 0 at the start of each strip (for line strips), and before |
| every line segment in a group of independent segments. |
| |
| If the line segment has been clipped, then the value of _s_ at the beginning |
| of the line segment is implementation-dependent. |
| |
| [open,refpage='vkCmdSetLineStippleEXT',desc='Set line stipple dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the line stipple state, |
| call: |
| |
| include::{generated}/api/protos/vkCmdSetLineStippleEXT.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:lineStippleFactor is the repeat factor used in stippled line |
| rasterization. |
| * pname:lineStipplePattern is the bit pattern used in stippled line |
| rasterization. |
| |
| This command sets the line stipple state for subsequent drawing commands |
| when the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_LINE_STIPPLE_EXT set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineRasterizationLineStateCreateInfoEXT::pname:lineStippleFactor |
| and |
| slink:VkPipelineRasterizationLineStateCreateInfoEXT::pname:lineStipplePattern |
| values used to create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776]] |
| pname:lineStippleFactor must: be in the range [eq]#[1,256]# |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetLineStippleEXT.txt[] |
| -- |
| |
| |
| [[primsrast-lines-smooth]] |
| === Smooth Lines |
| |
| If the pname:lineRasterizationMode member of |
| slink:VkPipelineRasterizationLineStateCreateInfoEXT is |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then lines are |
| considered to be rectangles using the same geometry as for |
| ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT lines. |
| The rules for determining which pixels are covered are |
| implementation-dependent, and may: include nearby pixels where no sample |
| locations are covered or where the rectangle does not intersect the pixel at |
| all. |
| For each pixel that is considered covered, the fragment computes a coverage |
| value that approximates the area of the intersection of the rectangle with |
| the pixel square, and this coverage value is multiplied into the color |
| location 0's alpha value after fragment shading, as described in |
| <<fragops-covg,Multisample Coverage>>. |
| |
| [NOTE] |
| .Note |
| ==== |
| The details of the rasterization rules and area calculation are left |
| intentionally vague, to allow implementations to generate coverage and |
| values that are aesthetically pleasing. |
| ==== |
| endif::VK_EXT_line_rasterization[] |
| |
| |
| [[primsrast-polygons]] |
| == Polygons |
| |
| A polygon results from the decomposition of a triangle strip, triangle fan |
| or a series of independent triangles. |
| Like points and line segments, polygon rasterization is controlled by |
| several variables in the slink:VkPipelineRasterizationStateCreateInfo |
| structure. |
| |
| |
| [[primsrast-polygons-basic]] |
| === Basic Polygon Rasterization |
| |
| [open,refpage='VkFrontFace',desc='Interpret polygon front-facing orientation',type='enums'] |
| -- |
| The first step of polygon rasterization is to determine whether the triangle |
| is _back-facing_ or _front-facing_. |
| This determination is made based on the sign of the (clipped or unclipped) |
| polygon's area computed in framebuffer coordinates. |
| One way to compute this area is: |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| a = -{1 \over 2}\sum_{i=0}^{n-1} |
| x_f^i y_f^{i \oplus 1} - |
| x_f^{i \oplus 1} y_f^i |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| where latexmath:[x_f^i] and latexmath:[y_f^i] are the [eq]#x# and [eq]#y# |
| framebuffer coordinates of the [eq]##i##th vertex of the [eq]#n#-vertex |
| polygon (vertices are numbered starting at zero for the purposes of this |
| computation) and [eq]#i {oplus} 1# is [eq]#(i {plus} 1) mod n#. |
| |
| The interpretation of the sign of [eq]#a# is determined by the |
| slink:VkPipelineRasterizationStateCreateInfo::pname:frontFace property of |
| the currently active pipeline. |
| Possible values are: |
| |
| include::{generated}/api/enums/VkFrontFace.txt[] |
| |
| * ename:VK_FRONT_FACE_COUNTER_CLOCKWISE specifies that a triangle with |
| positive area is considered front-facing. |
| * ename:VK_FRONT_FACE_CLOCKWISE specifies that a triangle with negative |
| area is considered front-facing. |
| |
| Any triangle which is not front-facing is back-facing, including zero-area |
| triangles. |
| -- |
| |
| ifdef::VK_EXT_extended_dynamic_state[] |
| [open,refpage='vkCmdSetFrontFaceEXT',desc='Set front face orientation dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the front face orientation, |
| call: |
| |
| include::{generated}/api/protos/vkCmdSetFrontFaceEXT.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:frontFace is a elink:VkFrontFace value specifying the front-facing |
| triangle orientation to be used for culling. |
| |
| This command sets the front face orientation for subsequent drawing commands |
| when the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_FRONT_FACE_EXT set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineRasterizationStateCreateInfo::pname:frontFace value used to |
| create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetFrontFaceEXT-None-03383]] |
| The <<features-extendedDynamicState, extendedDynamicState>> feature |
| must: be enabled |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetFrontFaceEXT.txt[] |
| -- |
| endif::VK_EXT_extended_dynamic_state[] |
| |
| |
| [open,refpage='VkCullModeFlagBits',desc='Bitmask controlling triangle culling',type='enums'] |
| -- |
| Once the orientation of triangles is determined, they are culled according |
| to the slink:VkPipelineRasterizationStateCreateInfo::pname:cullMode property |
| of the currently active pipeline. |
| Possible values are: |
| |
| include::{generated}/api/enums/VkCullModeFlagBits.txt[] |
| |
| * ename:VK_CULL_MODE_NONE specifies that no triangles are discarded |
| * ename:VK_CULL_MODE_FRONT_BIT specifies that front-facing triangles are |
| discarded |
| * ename:VK_CULL_MODE_BACK_BIT specifies that back-facing triangles are |
| discarded |
| * ename:VK_CULL_MODE_FRONT_AND_BACK specifies that all triangles are |
| discarded. |
| |
| Following culling, fragments are produced for any triangles which have not |
| been discarded. |
| -- |
| |
| [open,refpage='VkCullModeFlags',desc='Bitmask of VkCullModeFlagBits',type='flags'] |
| -- |
| include::{generated}/api/flags/VkCullModeFlags.txt[] |
| |
| tname:VkCullModeFlags is a bitmask type for setting a mask of zero or more |
| elink:VkCullModeFlagBits. |
| -- |
| |
| ifdef::VK_EXT_extended_dynamic_state[] |
| [open,refpage='vkCmdSetCullModeEXT',desc='Set cull mode dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the cull mode, call: |
| |
| include::{generated}/api/protos/vkCmdSetCullModeEXT.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:cullMode specifies the cull mode property to use for drawing. |
| |
| This command sets the cull mode for subsequent drawing commands when the |
| graphics pipeline is created with ename:VK_DYNAMIC_STATE_CULL_MODE_EXT set |
| in slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineRasterizationStateCreateInfo::pname:cullMode value used to |
| create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetCullModeEXT-None-03384]] |
| The <<features-extendedDynamicState, extendedDynamicState>> feature |
| must: be enabled |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetCullModeEXT.txt[] |
| -- |
| endif::VK_EXT_extended_dynamic_state[] |
| |
| The rule for determining which fragments are produced by polygon |
| rasterization is called _point sampling_. |
| The two-dimensional projection obtained by taking the x and y framebuffer |
| coordinates of the polygon's vertices is formed. |
| Fragments are produced for any fragment area groups of pixels for which any |
| sample points lie inside of this polygon. |
| Coverage bits that correspond to sample points that satisfy the point |
| sampling criteria are 1, other coverage bits are 0. |
| Special treatment is given to a sample whose sample location lies on a |
| polygon edge. |
| In such a case, if two polygons lie on either side of a common edge (with |
| identical endpoints) on which a sample point lies, then exactly one of the |
| polygons must: result in a covered sample for that fragment during |
| rasterization. |
| As for the data associated with each fragment produced by rasterizing a |
| polygon, we begin by specifying how these values are produced for fragments |
| in a triangle. |
| |
| [[primsrast-polygon-barycentrics]] |
| _Barycentric coordinates_ are a set of three numbers, [eq]#a#, [eq]#b#, and |
| [eq]#c#, each in the range [eq]#[0,1]#, with [eq]#a {plus} b {plus} c = 1#. |
| These coordinates uniquely specify any point [eq]#p# within the triangle or |
| on the triangle's boundary as |
| |
| {empty}:: [eq]#p = a p~a~ {plus} b p~b~ {plus} c p~c~# |
| |
| where [eq]#p~a~#, [eq]#p~b~#, and [eq]#p~c~# are the vertices of the |
| triangle. |
| [eq]#a#, [eq]#b#, and [eq]#c# are determined by: |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| a = {{\mathrm{A}(p p_b p_c)} \over {\mathrm{A}(p_a p_b p_c)}}, \quad |
| b = {{\mathrm{A}(p p_a p_c)} \over {\mathrm{A}(p_a p_b p_c)}}, \quad |
| c = {{\mathrm{A}(p p_a p_b)} \over {\mathrm{A}(p_a p_b p_c)}}, |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| where [eq]#A(lmn)# denotes the area in framebuffer coordinates of the |
| triangle with vertices [eq]#l#, [eq]#m#, and [eq]#n#. |
| |
| Denote an associated datum at [eq]#p~a~#, [eq]#p~b~#, or [eq]#p~c~# as |
| [eq]#f~a~#, [eq]#f~b~#, or [eq]#f~c~#, respectively. |
| |
| [[triangle_perspective_interpolation]] |
| The value of an associated datum [eq]#f# for a fragment produced by |
| rasterizing a triangle, whether it be a shader output or the clip [eq]#w# |
| coordinate, must: be determined using perspective interpolation: |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| f = { a {f_a / w_a} + b {f_b / w_b} + c {f_c / w_c} } \over |
| { {a / w_a} + {b / w_b} + {c / w_c} } |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| where [eq]#w~a~#, [eq]#w~b~#, and [eq]#w~c~# are the clip [eq]#w# |
| coordinates of [eq]#p~a~#, [eq]#p~b~#, and [eq]#p~c~#, respectively. |
| [eq]#a#, [eq]#b#, and [eq]#c# are the barycentric coordinates of the |
| location at which the data are produced - this must: be the location of the |
| fragment center or the location of a sample. |
| When pname:rasterizationSamples is ename:VK_SAMPLE_COUNT_1_BIT, the fragment |
| center must: be used. |
| |
| [[triangle_linear_interpolation]] |
| Depth values for triangles must: be determined using linear interpolation: |
| |
| {empty}:: [eq]#z = a z~a~ {plus} b z~b~ {plus} c z~c~# |
| |
| where [eq]#z~a~#, [eq]#z~b~#, and [eq]#z~c~# are the depth values of |
| [eq]#p~a~#, [eq]#p~b~#, and [eq]#p~c~#, respectively. |
| |
| The code:NoPerspective and code:Flat |
| <<shaders-interpolation-decorations,interpolation decorations>> can: be used |
| with fragment shader inputs to declare how they are interpolated. |
| When neither decoration is applied, <<triangle_perspective_interpolation, |
| perspective interpolation>> is performed as described above. |
| When the code:NoPerspective decoration is used, |
| <<triangle_linear_interpolation, linear interpolation>> is performed in the |
| same fashion as for depth values, as described above. |
| When the code:Flat decoration is used, no interpolation is performed, and |
| outputs are taken from the corresponding input value of the |
| <<vertexpostproc-flatshading,provoking vertex>> corresponding to that |
| primitive. |
| |
| ifdef::VK_AMD_shader_explicit_vertex_parameter[] |
| When the `apiext:VK_AMD_shader_explicit_vertex_parameter` device extension |
| is enabled the code:CustomInterpAMD <<shaders-interpolation-decorations, |
| interpolation decoration>> can: also be used with fragment shader inputs |
| which indicate that the decorated inputs can: only be accessed by the |
| extended instruction code:InterpolateAtVertexAMD and allows accessing the |
| value of the inputs for individual vertices of the primitive. |
| endif::VK_AMD_shader_explicit_vertex_parameter[] |
| |
| ifdef::VK_NV_fragment_shader_barycentric[] |
| When the pname:fragmentShaderBarycentric feature is enabled, the |
| code:PerVertexNV <<shaders-interpolation-decorations, interpolation |
| decoration>> can: also be used with fragment shader inputs which indicate |
| that the decorated inputs are not interpolated and can: only be accessed |
| using an extra array dimension, where the extra index identifies one of the |
| vertices of the primitive that produced the fragment. |
| endif::VK_NV_fragment_shader_barycentric[] |
| |
| For a polygon with more than three edges, such as are produced by clipping a |
| triangle, a convex combination of the values of the datum at the polygon's |
| vertices must: be used to obtain the value assigned to each fragment |
| produced by the rasterization algorithm. |
| That is, it must: be the case that at every fragment |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| f = \sum_{i=1}^{n} a_i f_i |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| where [eq]#n# is the number of vertices in the polygon and [eq]#f~i~# is the |
| value of [eq]#f# at vertex [eq]#i#. |
| For each [eq]#i#, [eq]#0 {leq} a~i~ {leq} 1# and |
| latexmath:[\sum_{i=1}^{n}a_i = 1]. |
| The values of [eq]#a~i~# may: differ from fragment to fragment, but at |
| vertex [eq]#i#, [eq]#a~i~ = 1# and [eq]#a~j~ = 0# for [eq]#j {neq} i#. |
| |
| [NOTE] |
| .Note |
| ==== |
| One algorithm that achieves the required behavior is to triangulate a |
| polygon (without adding any vertices) and then treat each triangle |
| individually as already discussed. |
| A scan-line rasterizer that linearly interpolates data along each edge and |
| then linearly interpolates data across each horizontal span from edge to |
| edge also satisfies the restrictions (in this case the numerator and |
| denominator of <<triangle_perspective_interpolation, perspective |
| interpolation>> are iterated independently, and a division is performed for |
| each fragment). |
| ==== |
| |
| |
| [[primsrast-polygonmode]] |
| === Polygon Mode |
| |
| [open,refpage='VkPolygonMode',desc='Control polygon rasterization mode',type='enums'] |
| -- |
| Possible values of the |
| slink:VkPipelineRasterizationStateCreateInfo::pname:polygonMode property of |
| the currently active pipeline, specifying the method of rasterization for |
| polygons, are: |
| |
| include::{generated}/api/enums/VkPolygonMode.txt[] |
| |
| * ename:VK_POLYGON_MODE_POINT specifies that polygon vertices are drawn as |
| points. |
| * ename:VK_POLYGON_MODE_LINE specifies that polygon edges are drawn as |
| line segments. |
| * ename:VK_POLYGON_MODE_FILL specifies that polygons are rendered using |
| the polygon rasterization rules in this section. |
| ifdef::VK_NV_fill_rectangle[] |
| * ename:VK_POLYGON_MODE_FILL_RECTANGLE_NV specifies that polygons are |
| rendered using polygon rasterization rules, modified to consider a |
| sample within the primitive if the sample location is inside the |
| axis-aligned bounding box of the triangle after projection. |
| Note that the barycentric weights used in attribute interpolation can: |
| extend outside the range [eq]#[0,1]# when these primitives are shaded. |
| Special treatment is given to a sample position on the boundary edge of |
| the bounding box. |
| In such a case, if two rectangles lie on either side of a common edge |
| (with identical endpoints) on which a sample position lies, then exactly |
| one of the triangles must: produce a fragment that covers that sample |
| during rasterization. |
| + |
| Polygons rendered in ename:VK_POLYGON_MODE_FILL_RECTANGLE_NV mode may: be |
| clipped by the frustum or by user clip planes. |
| If clipping is applied, the triangle is culled rather than clipped. |
| + |
| Area calculation and facingness are determined for |
| ename:VK_POLYGON_MODE_FILL_RECTANGLE_NV mode using the triangle's vertices. |
| endif::VK_NV_fill_rectangle[] |
| |
| These modes affect only the final rasterization of polygons: in particular, |
| a polygon's vertices are shaded and the polygon is clipped and possibly |
| culled before these modes are applied. |
| -- |
| |
| |
| [[primsrast-depthbias]] |
| === Depth Bias |
| |
| The depth values of all fragments generated by the rasterization of a |
| polygon can: be biased (offset) by a single depth bias value latexmath:[o] |
| that is computed for that polygon. |
| |
| |
| [[primsrast-depthbias-enable]] |
| ==== Depth Bias Enable |
| |
| The depth bias computation is enabled by the |
| ifdef::VK_EXT_extended_dynamic_state2[] |
| pname:depthBiasEnable set with flink:vkCmdSetDepthBiasEnableEXT, or the |
| corresponding |
| endif::VK_EXT_extended_dynamic_state2[] |
| slink:VkPipelineRasterizationStateCreateInfo::pname:depthBiasEnable value |
| used to create the currently active pipeline. |
| If the depth bias enable is ename:VK_FALSE, no bias is applied and the |
| fragment's depth values are unchanged. |
| |
| ifdef::VK_EXT_extended_dynamic_state2[] |
| [open,refpage='vkCmdSetDepthBiasEnableEXT',desc='Control whether to bias fragment depth values dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically enable>> whether to bias fragment |
| depth values, call: |
| |
| include::{generated}/api/protos/vkCmdSetDepthBiasEnableEXT.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:depthBiasEnable controls whether to bias fragment depth values. |
| |
| This command sets the depth bias enable for subsequent drawing commands when |
| the graphics pipeline is created with |
| ename:VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT set in |
| slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the |
| slink:VkPipelineRasterizationStateCreateInfo::pname:depthBiasEnable value |
| used to create the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetDepthBiasEnableEXT-None-04872]] |
| The <<features-extendedDynamicState2, extendedDynamicState2>> feature |
| must: be enabled |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetDepthBiasEnableEXT.txt[] |
| -- |
| endif::VK_EXT_extended_dynamic_state2[] |
| |
| |
| [[primsrast-depthbias-computation]] |
| ==== Depth Bias Computation |
| |
| The depth bias depends on three parameters: |
| |
| * pname:depthBiasSlopeFactor scales the maximum depth slope [eq]#m# of the |
| polygon |
| * pname:depthBiasConstantFactor scales the minimum resolvable difference |
| [eq]#r# of the depth buffer |
| * the scaled terms are summed to produce a value which is then clamped to |
| a minimum or maximum value specified by pname:depthBiasClamp |
| |
| pname:depthBiasSlopeFactor, pname:depthBiasConstantFactor, and |
| pname:depthBiasClamp can: each be positive, negative, or zero. |
| These parameters are set as described for flink:vkCmdSetDepthBias below. |
| |
| The maximum depth slope [eq]#m# of a triangle is |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| m = \sqrt{ \left({{\partial z_f} \over {\partial x_f}}\right)^2 |
| + \left({{\partial z_f} \over {\partial y_f}}\right)^2} |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| where [eq]#(x~f~, y~f~, z~f~)# is a point on the triangle. |
| [eq]#m# may: be approximated as |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| m = \max\left( \left| { {\partial z_f} \over {\partial x_f} } \right|, |
| \left| { {\partial z_f} \over {\partial y_f} } \right| |
| \right). |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| The minimum resolvable difference [eq]#r# is a parameter that depends on the |
| depth buffer representation. |
| It is the smallest difference in framebuffer coordinate [eq]#z# values that |
| is guaranteed to remain distinct throughout polygon rasterization and in the |
| depth buffer. |
| All pairs of fragments generated by the rasterization of two polygons with |
| otherwise identical vertices, but [eq]#pname:z~f~# values that differ by |
| [eq]#r#, will have distinct depth values. |
| |
| For fixed-point depth buffer representations, [eq]#r# is constant throughout |
| the range of the entire depth buffer. |
| Its value is implementation-dependent but must: be at most |
| |
| {empty}:: [eq]#r = 2 {times} 2^-n^# |
| |
| for an n-bit buffer. |
| For floating-point depth buffers, there is no single minimum resolvable |
| difference. |
| In this case, the minimum resolvable difference for a given polygon is |
| dependent on the maximum exponent, [eq]#e#, in the range of [eq]#z# values |
| spanned by the primitive. |
| If [eq]#n# is the number of bits in the floating-point mantissa, the minimum |
| resolvable difference, [eq]#r#, for the given primitive is defined as |
| |
| {empty}:: [eq]#r = 2^e-n^# |
| |
| ifdef::VK_NV_fill_rectangle[] |
| If a triangle is rasterized using the |
| ename:VK_POLYGON_MODE_FILL_RECTANGLE_NV polygon mode, then this minimum |
| resolvable difference may: not be resolvable for samples outside of the |
| triangle, where the depth is extrapolated. |
| endif::VK_NV_fill_rectangle[] |
| |
| If no depth buffer is present, [eq]#r# is undefined:. |
| |
| The bias value [eq]#o# for a polygon is |
| |
| [latexmath] |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| \begin{aligned} |
| o &= \mathrm{dbclamp}( m \times \mathtt{depthBiasSlopeFactor} + r \times \mathtt{depthBiasConstantFactor} ) \\ |
| \text{where} &\quad \mathrm{dbclamp}(x) = |
| \begin{cases} |
| x & \mathtt{depthBiasClamp} = 0 \ \text{or}\ \texttt{NaN} \\ |
| \min(x, \mathtt{depthBiasClamp}) & \mathtt{depthBiasClamp} > 0 \\ |
| \max(x, \mathtt{depthBiasClamp}) & \mathtt{depthBiasClamp} < 0 \\ |
| \end{cases} |
| \end{aligned} |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| |
| [eq]#m# is computed as described above. |
| If the depth buffer uses a fixed-point representation, [eq]#m# is a function |
| of depth values in the range [eq]#[0,1]#, and [eq]#o# is applied to depth |
| values in the same range. |
| |
| [open,refpage='vkCmdSetDepthBias',desc='Set depth bias factors and clamp dynamically for a command buffer',type='protos'] |
| -- |
| To <<pipelines-dynamic-state, dynamically set>> the depth bias parameters, |
| call: |
| |
| include::{generated}/api/protos/vkCmdSetDepthBias.txt[] |
| |
| * pname:commandBuffer is the command buffer into which the command will be |
| recorded. |
| * pname:depthBiasConstantFactor is a scalar factor controlling the |
| constant depth value added to each fragment. |
| * pname:depthBiasClamp is the maximum (or minimum) depth bias of a |
| fragment. |
| * pname:depthBiasSlopeFactor is a scalar factor applied to a fragment's |
| slope in depth bias calculations. |
| |
| This command sets the depth bias parameters for subsequent drawing commands |
| when the graphics pipeline is created with ename:VK_DYNAMIC_STATE_DEPTH_BIAS |
| set in slink:VkPipelineDynamicStateCreateInfo::pname:pDynamicStates. |
| Otherwise, this state is specified by the corresponding |
| slink:VkPipelineInputAssemblyStateCreateInfo::pname:depthBiasConstantFactor, |
| pname:depthBiasClamp, and pname:depthBiasSlopeFactor values used to create |
| the currently active pipeline. |
| |
| .Valid Usage |
| **** |
| * [[VUID-vkCmdSetDepthBias-depthBiasClamp-00790]] |
| If the <<features-depthBiasClamp,depth bias clamping>> feature is not |
| enabled, pname:depthBiasClamp must: be `0.0` |
| **** |
| |
| include::{generated}/validity/protos/vkCmdSetDepthBias.txt[] |
| -- |
| |
| |
| ifdef::VK_EXT_conservative_rasterization[] |
| [[primsrast-conservativeraster]] |
| === Conservative Rasterization |
| |
| [open,refpage='VkPipelineRasterizationConservativeStateCreateInfoEXT',desc='Structure specifying conservative raster state',type='structs'] |
| -- |
| Polygon rasterization can: be made conservative by setting |
| pname:conservativeRasterizationMode to |
| ename:VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT or |
| ename:VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT in |
| sname:VkPipelineRasterizationConservativeStateCreateInfoEXT. |
| The sname:VkPipelineRasterizationConservativeStateCreateInfoEXT state is set |
| by adding this structure to the pname:pNext chain of a |
| sname:VkPipelineRasterizationStateCreateInfo structure when creating the |
| graphics pipeline. |
| Enabling these modes also affects line and point rasterization if the |
| implementation sets |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:conservativePointAndLineRasterization |
| to ename:VK_TRUE. |
| |
| sname:VkPipelineRasterizationConservativeStateCreateInfoEXT is defined as: |
| |
| include::{generated}/api/structs/VkPipelineRasterizationConservativeStateCreateInfoEXT.txt[] |
| |
| * pname:sType is the type of this structure. |
| * pname:pNext is `NULL` or a pointer to a structure extending this |
| structure. |
| * pname:flags is reserved for future use. |
| * pname:conservativeRasterizationMode is the conservative rasterization |
| mode to use. |
| * pname:extraPrimitiveOverestimationSize is the extra size in pixels to |
| increase the generating primitive during conservative rasterization at |
| each of its edges in `X` and `Y` equally in screen space beyond the base |
| overestimation specified in |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:primitiveOverestimationSize. |
| |
| .Valid Usage |
| **** |
| * [[VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769]] |
| pname:extraPrimitiveOverestimationSize must: be in the range of `0.0` to |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:maxExtraPrimitiveOverestimationSize |
| inclusive |
| **** |
| |
| include::{generated}/validity/structs/VkPipelineRasterizationConservativeStateCreateInfoEXT.txt[] |
| -- |
| |
| [open,refpage='VkPipelineRasterizationConservativeStateCreateFlagsEXT',desc='Reserved for future use',type='flags'] |
| -- |
| include::{generated}/api/flags/VkPipelineRasterizationConservativeStateCreateFlagsEXT.txt[] |
| |
| tname:VkPipelineRasterizationConservativeStateCreateFlagsEXT is a bitmask |
| type for setting a mask, but is currently reserved for future use. |
| -- |
| |
| [open,refpage='VkConservativeRasterizationModeEXT',desc='Specify the conservative rasterization mode',type='enums'] |
| -- |
| Possible values of |
| slink:VkPipelineRasterizationConservativeStateCreateInfoEXT::pname:conservativeRasterizationMode, |
| specifying the conservative rasterization mode are: |
| |
| include::{generated}/api/enums/VkConservativeRasterizationModeEXT.txt[] |
| |
| * ename:VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT specifies that |
| conservative rasterization is disabled and rasterization proceeds as |
| normal. |
| * ename:VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT specifies that |
| conservative rasterization is enabled in overestimation mode. |
| * ename:VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT specifies |
| that conservative rasterization is enabled in underestimation mode. |
| -- |
| |
| When overestimate conservative rasterization is enabled, rather than |
| evaluating coverage at individual sample locations, a determination is made |
| of whether any portion of the pixel (including its edges and corners) is |
| covered by the primitive. |
| If any portion of the pixel is covered, then all bits of the |
| <<primsrast-multisampling-coverage-mask, coverage mask>> for the fragment |
| corresponding to that pixel are enabled. |
| ifdef::VK_EXT_fragment_density_map[] |
| If the render pass has a fragment density map attachment and any bit of the |
| <<primsrast-multisampling-coverage-mask, coverage mask>> for the fragment is |
| enabled, then all bits of the <<primsrast-multisampling-coverage-mask, |
| coverage mask>> for the fragment are enabled. |
| endif::VK_EXT_fragment_density_map[] |
| |
| For the purposes of evaluating which pixels are covered by the primitive, |
| implementations can: increase the size of the primitive by up to |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:primitiveOverestimationSize |
| pixels at each of the primitive edges. |
| This may: increase the number of fragments generated by this primitive and |
| represents an overestimation of the pixel coverage. |
| |
| This overestimation size can be increased further by setting the |
| pname:extraPrimitiveOverestimationSize value above `0.0` in steps of |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:extraPrimitiveOverestimationSizeGranularity |
| up to and including |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:extraPrimitiveOverestimationSize. |
| This will: further increase the number of fragments generated by this |
| primitive. |
| |
| The actual precision of the overestimation size used for conservative |
| rasterization may: vary between implementations and produce results that |
| only approximate the pname:primitiveOverestimationSize and |
| pname:extraPrimitiveOverestimationSizeGranularity properties. |
| ifdef::VK_EXT_fragment_density_map[] |
| Implementations may: especially vary these approximations when the render |
| pass has a fragment density map and the fragment area covers multiple |
| pixels. |
| endif::VK_EXT_fragment_density_map[] |
| |
| For triangles if ename:VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT |
| is enabled, fragments will be generated if the primitive area covers any |
| portion of any pixel inside the fragment area, including their edges or |
| corners. |
| The tie-breaking rule described in <<primsrast-polygons-basic, Basic Polygon |
| Rasterization>> does not apply during conservative rasterization and |
| coverage is set for all fragments generated from shared edges of polygons. |
| Degenerate triangles that evaluate to zero area after rasterization, even |
| for pixels containing a vertex or edge of the zero-area polygon, will be |
| culled if |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:degenerateTrianglesRasterized |
| is ename:VK_FALSE or will generate fragments if |
| pname:degenerateTrianglesRasterized is ename:VK_TRUE. |
| The fragment input values for these degenerate triangles take their |
| attribute and depth values from the provoking vertex. |
| Degenerate triangles are considered backfacing and the application can: |
| enable backface culling if desired. |
| Triangles that are zero area before rasterization may: be culled regardless. |
| |
| For lines if ename:VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT is |
| enabled, and the implementation sets |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:conservativePointAndLineRasterization |
| to ename:VK_TRUE, fragments will be generated if the line covers any portion |
| of any pixel inside the fragment area, including their edges or corners. |
| Degenerate lines that evaluate to zero length after rasterization will be |
| culled if |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:degenerateLinesRasterized |
| is ename:VK_FALSE or will generate fragments if |
| pname:degenerateLinesRasterized is ename:VK_TRUE. |
| The fragments input values for these degenerate lines take their attribute |
| and depth values from the provoking vertex. |
| Lines that are zero length before rasterization may: be culled regardless. |
| |
| For points if ename:VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT is |
| enabled, and the implementation sets |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:conservativePointAndLineRasterization |
| to ename:VK_TRUE, fragments will be generated if the point square covers any |
| portion of any pixel inside the fragment area, including their edges or |
| corners. |
| |
| When underestimate conservative rasterization is enabled, rather than |
| evaluating coverage at individual sample locations, a determination is made |
| of whether all of the pixel (including its edges and corners) is covered by |
| the primitive. |
| If the entire pixel is covered, then a fragment is generated with all bits |
| of its <<primsrast-multisampling-coverage-mask, coverage mask>> |
| corresponding to the pixel enabled, otherwise the pixel is not considered |
| covered even if some portion of the pixel is covered. |
| The fragment is discarded if no pixels inside the fragment area are |
| considered covered. |
| ifdef::VK_EXT_fragment_density_map[] |
| If the render pass has a fragment density map attachment and any pixel |
| inside the fragment area is not considered covered, then the fragment is |
| discarded even if some pixels are considered covered. |
| endif::VK_EXT_fragment_density_map[] |
| |
| For triangles, if ename:VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT |
| is enabled, fragments will only be generated if any pixel inside the |
| fragment area is fully covered by the generating primitive, including its |
| edges and corners. |
| |
| For lines, if ename:VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT is |
| enabled, fragments will be generated if any pixel inside the fragment area, |
| including its edges and corners, are entirely covered by the line. |
| |
| For points, if ename:VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT is |
| enabled, fragments will only be generated if the point square covers the |
| entirety of any pixel square inside the fragment area, including its edges |
| or corners. |
| |
| ifdef::VK_EXT_fragment_density_map[] |
| If the render pass has a fragment density map and |
| ename:VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT is enabled, |
| fragments will only be generated if the entirety of all pixels inside the |
| fragment area are covered by the generating primitive, line, or point. |
| endif::VK_EXT_fragment_density_map[] |
| |
| For both overestimate and underestimate conservative rasterization modes a |
| fragment has all of its pixel squares fully covered by the generating |
| primitive must: set code:FullyCoveredEXT to ename:VK_TRUE if the |
| implementation enables the |
| sname:VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pname:fullyCoveredFragmentShaderInputVariable |
| feature. |
| |
| ifdef::VK_NV_shading_rate_image,VK_KHR_fragment_shading_rate[] |
| When |
| ifdef::VK_NV_shading_rate_image[] |
| the use of a <<primsrast-shading-rate-image, shading rate image>> |
| endif::VK_NV_shading_rate_image[] |
| ifdef::VK_NV_shading_rate_image+VK_KHR_fragment_shading_rate[or] |
| ifdef::VK_KHR_fragment_shading_rate[] |
| setting the <<primsrast-fragment-shading-rate, fragment shading rate>> |
| endif::VK_KHR_fragment_shading_rate[] |
| results in fragments covering multiple pixels, coverage for conservative |
| rasterization is still evaluated on a per-pixel basis and may result in |
| fragments with partial coverage. |
| For fragment shader inputs decorated with code:FullyCoveredEXT, a fragment |
| is considered fully covered if and only if all pixels in the fragment are |
| fully covered by the generating primitive. |
| endif::VK_NV_shading_rate_image,VK_KHR_fragment_shading_rate[] |
| |
| endif::VK_EXT_conservative_rasterization[] |
