Fragment Density Map Operations

Fragment Density Map Operations Overview

When a fragment is generated in a render pass that has a fragment density map attachment, its area is determined by the properties of the local framebuffer region that the fragment occupies. The framebuffer is divided into a uniform grid of these local regions, and their fragment area property is derived from the density map with the following operations:

Fetch Density Value

Each local framebuffer region at center coordinate (x,y) reads a texel from the fragment density map.

First, the local framebuffer region center coordinate (x,y) is offset by the value specified in VkRenderPassFragmentDensityMapOffsetEndInfoEXT. If no offset is specified, then the default offset (0,0) is used. The offset coordinate (x',y') is computed as follows:

\begin{aligned} x' &= x - pFragmentDensityOffsets\[layer]*{x} \\ y' &= y - pFragmentDensityOffsets\[layer]*{y} \\ \end{aligned}

The offset is relative to the fragment density map, so it is subtracted from the framebuffer coordinates to make the adjustment relative to the framebuffer.In other words, applying a positive offset in the x component will shift the fragment density map to the right relative to the framebuffer. This means the framebuffer coordinates need to undergo a shift to the left.

The offset fragment coordinate (x',y') reads a texel from the fragment density map at image coordinates (x,y,0,layer,0,0), where (x,y) are calculated as:

$x = \mathbin{clamp}(\left\lfloor{\frac{x'}{fragmentDensityTexelSize\_{width}}}\right\rfloor, 0, fragmentDensityMap\_{width} - 1)$
$y = \mathbin{clamp}(\left\lfloor{\frac{y'}{fragmentDensityTexelSize\_{height}}}\right\rfloor, 0, fragmentDensityMap\_{height} - 1)$

Where the size of each region in the framebuffer is:

$fragmentDensityTexelSize'*{width} = {2^{\lceil{\log\_2(\lfloor{\frac{framebuffer*{width}}{fragmentDensityMap\_{width}}}\rfloor)}\rceil}}$
$fragmentDensityTexelSize'*{height} = {2^{\lceil{\log\_2(\lfloor{\frac{framebuffer*{height}}{fragmentDensityMap\_{height}}}\rfloor)}\rceil}}$

The original spec did not include the floor in the equation above. Implementations have shipped with and without the floor. Given that the earliest implementations shipped with the floor, the spec now reflects that as most content was written with this behavior.All implementations exposing support for version 3 or greater of the extension must implement with the floor included.

If using vkCmdBeginRendering, then $framebuffer\_{width}$ and $framebuffer\_{height}$ are defined as:

$framebuffer\_{width} = renderAreaOffset\_{x} {plus} renderAreaExtent\_{width}$
$framebuffer\_{height} = renderAreaOffset\_{y} {plus} renderAreaExtent\_{height}$

using VkRenderingInfo::renderArea.

This region is subject to the limits in VkPhysicalDeviceFragmentDensityMapPropertiesEXT and therefore the final region size is clamped:

$fragmentDensityTexelSize\_{width} = \mathbin{clamp}(fragmentDensityTexelSize'*{width},minFragmentDensityTexelSize*{width},maxFragmentDensityTexelSize\_{width})$
$fragmentDensityTexelSize\_{height} = \mathbin{clamp}(fragmentDensityTexelSize'*{height},minFragmentDensityTexelSize*{height},maxFragmentDensityTexelSize\_{height})$

When multiview is enabled for the render pass and the fragment density map attachment view was created with layerCount greater than 1, the layer used for offsets and for fetching from the fragment density map is:

$layer = baseArrayLayer + ViewIndex$

Otherwise, if the render pass was created with VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE specified, or the dynamic render pass was begun with VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE specified, then the layer used is:

$layer = baseArrayLayer + Layer$

Otherwise:

$layer = baseArrayLayer$

The texel fetched from the density map at (x,y,0,layer,0,0) is next converted to density with the following operations.

Component Swizzle

The components member of VkImageViewCreateInfo is applied to the fetched texel as defined in Image component swizzle.

Component Mapping

The swizzled texel’s components are mapped to a density value:

$densityValue\_{xy} = (C'*{r},C'*{g})$

Fragment Area Conversion

Fragment area for the framebuffer region is undefined if the density fetched is not a normalized floating-point value greater than 0.0. Otherwise, the fetched fragment area for that region is derived as:

$fragmentArea\_{wh} = \frac{1.0}{densityValue\_{xy}}$

Fragment Area Filter

Optionally, the implementation may fetch additional density map texels in an implementation defined window around (i,j). The texels follow the standard conversion steps up to and including fragment area conversion.

A single fetched fragment area for the framebuffer region is chosen by the implementation and must have an area between the min and max areas of the fetched set.

Fragment Area Clamp

The implementation may clamp the fetched fragment area to one that it supports. The clamped fragment area must have a size less than or equal to the original fetched value. Implementations may vary the supported set of fragment areas per framebuffer region. Fragment area (1,1) must always be in the supported set.

For example, if the fetched fragment area is (1,4) but the implementation only supports areas of {(1,1),(2,2)}, it could choose to clamp the area to (2,2) since it has the same size as (1,4). While this would produce fragments that have lower quality strictly in the x-axis, the overall density is maintained.

The clamped fragment area is assigned to the corresponding framebuffer region.