Rasterization is the process by which a primitive is converted to a two-dimensional image. Each point 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 (x,y) framebuffer coordinates, 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 subpixel 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 the early per-fragment tests, if enabled.
Several factors affect rasterization, including the members of
VkPipelineRasterizationStateCreateInfo
and
VkPipelineMultisampleStateCreateInfo
.
The VkPipelineRasterizationStateCreateInfo
structure is defined as:
typedef struct VkPipelineRasterizationStateCreateInfo { VkStructureType sType; const void* pNext; VkPipelineRasterizationStateCreateFlags flags; VkBool32 depthClampEnable; VkBool32 rasterizerDiscardEnable; VkPolygonMode polygonMode; VkCullModeFlags cullMode; VkFrontFace frontFace; VkBool32 depthBiasEnable; float depthBiasConstantFactor; float depthBiasClamp; float depthBiasSlopeFactor; float lineWidth; } VkPipelineRasterizationStateCreateInfo;
sType
is the type of this structure.
pNext
is NULL
or a pointer to an extension-specific structure.
flags
is reserved for future use.
depthClampEnable
controls whether to clamp the fragment’s depth
values instead of clipping primitives to the z planes of the frustum, as
described in Primitive Clipping.
rasterizerDiscardEnable
controls whether primitives are discarded
immediately before the rasterization stage.
polygonMode
is the triangle rendering mode.
See VkPolygonMode
.
cullMode
is the triangle facing direction used for primitive
culling.
See VkCullModeFlagBits
.
frontFace
is the front-facing triangle orientation to be used for
culling.
See VkFrontFace
.
depthBiasEnable
controls whether to bias fragment depth values.
depthBiasConstantFactor
is a scalar factor controlling the
constant depth value added to each fragment.
depthBiasClamp
is the maximum (or minimum) depth bias of a
fragment.
depthBiasSlopeFactor
is a scalar factor applied to a fragment’s
slope in depth bias calculations.
lineWidth
is the width of rasterized line segments.
The VkPipelineMultisampleStateCreateInfo
structure is defined as:
typedef struct VkPipelineMultisampleStateCreateInfo { VkStructureType sType; const void* pNext; VkPipelineMultisampleStateCreateFlags flags; VkSampleCountFlagBits rasterizationSamples; VkBool32 sampleShadingEnable; float minSampleShading; const VkSampleMask* pSampleMask; VkBool32 alphaToCoverageEnable; VkBool32 alphaToOneEnable; } VkPipelineMultisampleStateCreateInfo;
sType
is the type of this structure.
pNext
is NULL
or a pointer to an extension-specific structure.
flags
is reserved for future use.
rasterizationSamples
is a VkSampleCountFlagBits
specifying
the number of samples per pixel used in rasterization.
sampleShadingEnable
specifies that fragment shading executes
per-sample if VK_TRUE
, or per-fragment if VK_FALSE
, as
described in Sample Shading.
minSampleShading
is the minimum fraction of sample shading, as
described in Sample Shading.
pSampleMask
is a bitmask of static coverage information that is
ANDed with the coverage information generated during rasterization, as
described in Sample Mask.
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 Multisample Coverage
section.
alphaToOneEnable
controls whether the alpha component of the
fragment’s first color output is replaced with one as described in
Multisample Coverage.
Rasterization only produces fragments corresponding to pixels in the framebuffer. 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 early per-fragment tests described in Early Per-Fragment Tests.
Surviving fragments are processed by fragment shaders. Fragment shaders determine associated data for fragments, and can also modify or replace their assigned depth values.
If the subpass for which this pipeline is being created uses color and/or
depth/stencil attachments, then rasterizationSamples
must be the same
as the sample count for those subpass attachments.
Otherwise, rasterizationSamples
must follow the rules for a
zero-attachment subpass.