Vulkan® 1.3.264 - A Specification (with all registered extensions)

17. Fragment Density Map Operations

17.1. 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:

17.2. Fetch Density Value

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

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

x^{'} y^{'} = c l a m p (x + p F r a g m e n t D e n s i t y O f f s e t s [l a y e r]_{x}, 0, f r a m e b u f f e r_{w i d t h} - 1) = c l a m p (y + p F r a g m e n t D e n s i t y O f f s e t s [l a y e r]_{y}, 0, f r a m e b u f f e r_{h e i g h t} - 1)

The offsetted coordinate (x',y') fetches a texel from the fragment density map at integer coordinates:

: $i = ⌊ \frac{x ^{'}}{f r a g m e n t D e n s i t y T e x e l S i z e _{w i d t h}} ⌋$
: $j = ⌊ \frac{y ^{'}}{f r a g m e n t D e n s i t y T e x e l S i z e _{h e i g h t}} ⌋$

Where the size of each region in the framebuffer is:

: $f r a g m e n t D e n s i t y T e x e l S i z e_{w i d t h}^{'} = 2^{⌈ l o g_{2} (\frac{f r a m e b u f f e r _{w i d t h}}{f r a g m e n t D e n s i t y M a p _{w i d t h}}) ⌉}$
: $f r a g m e n t D e n s i t y T e x e l S i z e_{h e i g h t}^{'} = 2^{⌈ l o g_{2} (\frac{f r a m e b u f f e r _{h e i g h t}}{f r a g m e n t D e n s i t y M a p _{h e i g h t}}) ⌉}$

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

: $f r a g m e n t D e n s i t y T e x e l S i z e_{w i d t h} = c l a m p (f r a g m e n t D e n s i t y T e x e l S i z e_{w i d t h}^{'}, m i n F r a g m e n t D e n s i t y T e x e l S i z e_{w i d t h}, m a x F r a g m e n t D e n s i t y T e x e l S i z e_{w i d t h})$
: $f r a g m e n t D e n s i t y T e x e l S i z e_{h e i g h t} = c l a m p (f r a g m e n t D e n s i t y T e x e l S i z e_{h e i g h t}^{'}, m i n F r a g m e n t D e n s i t y T e x e l S i z e_{h e i g h t}, m a x F r a g m e n t D e n s i t y T e x e l S i z e_{h e i g h t})$

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:

: $l a y e r = b a s e A r r a y L a y e r + V i e w I n d e x$

Otherwise:

: $l a y e r = b a s e A r r a y L a y e r$

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

17.2.1. Component Swizzle

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

17.2.2. Component Mapping

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

: $d e n s i t y V a l u e_{x y} = (C_{r}^{'}, C_{g}^{'})$

17.3. 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:

: $f r a g m e n t A r e a_{w h} = \frac{1 . 0}{d e n s i t y V a l u e _{x y}}$

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

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

Note

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.