# Chapter 24. Rasterization

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;
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                                 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.