HORIZON HASKELLDocslts/ghc-9.14.x45dd5372026-10-11Search names, modules, packages, or :: a typeCtrl K

GHC 9.14.1 · lts/ghc-9.14.x · 45dd537 · 2026-10-11

Modulevulkan-3.27GHC2021

Vulkan.Extensions.VK_QCOM_tile_shading

Name

VK_QCOM_tile_shading - device extension

VK_QCOM_tile_shading

Name String

VK_QCOM_tile_shading

Extension Type

Device extension

Registered Extension Number

310

Revision

2

Ratification Status

Not ratified

Extension and Version Dependencies

VK_QCOM_tile_properties

SPIR-V Dependencies
Contact
Extension Proposal

VK_QCOM_tile_shading

Other Extension Metadata

Last Modified Date

2025-8-13

IP Status

No known IP claims.

Interactions and External Dependencies
  • This extension interacts with VK_KHR_dynamic_rendering

  • This extension interacts with VK_EXT_transform_feedback

  • This extension interacts with VK_EXT_debug_marker

  • This extension interacts with VK_EXT_attachment_feedback_loop_layout

  • This extension interacts with VK_KHR_dynamic_rendering_local_read

  • This extension interacts with VK_QCOM_image_processing

Contributors
  • Jeff Leger, Qualcomm

  • Matt Netsch, Qualcomm

  • Srihari Babu Alla, Qualcomm

  • Matthew Smith, Qualcomm

  • Kevin Matlage, Qualcomm

  • Alex Bourd, Qualcomm

Description

This extension exposes tile shading in Vulkan. Many mobile GPUs utilize Tile-Based Deferred Rendering (TBDR) to optimize for power and performance. Conversely, most desktop GPUs use immediate-mode rendering (IM). Adreno ™ GPUs uniquely have the ability to operate in either mode, and when this extension is not enabled, the Adreno driver will select the most optimal mode (TBDR or IM) based on the workload; this feature is called FlexRender ™. When this extension is in use, FlexRender is disabled and the GPU operates exclusively in TBDR wherever possible.

The TBDR mode divides the color and depth/stencil buffer attachments into a regular grid of smaller regions called “tiles”. When a render pass instance is submitted for execution on an Adreno GPU, the rendering is split into two phases: a single “visibility pass” followed by multiple “rendering passes” where a separate render pass is issued for each tile in the framebuffer.

The “visibility pass” processes the geometry: identifies which tiles are covered by each primitive, eliminates occluded primitives and unneeded state changes, and performs other tile-specific optimizations. The primitive coverage information collected during the visibility pass is used in the subsequent “rendering pass” for each tile. During the rendering pass for each tile, any primitives that were determined not to cover the current tile are skipped.

This deferred rasterization additionally utilizes a specialized high-bandwidth on-die memory, “tile memory”. Tile memory is dramatically more efficient than other device memory. The tile memory temporarily stores the color and other attachments for each tile during rasterization. After each tile is fully rasterized, the resulting tile is typically copied to device memory backing the attachment as specified by the render pass STORE_OP. The per-tile rendering passes occur independently for each tile, with multiple tiles potentially being processed in parallel.

This extension enables applications to leverage the power and performance of tile memory in new ways:

  • Adds a mechanism for recording dispatches or draws that are guaranteed to be executed per-tile.

  • Such draws bypass the above-mentioned visibility-based skipping and are guaranteed to be executed for every tile in the rendering pass.

  • Shaders can declare “tile attachments” variables, providing shader access to color, depth/stencil, and input attachment pixels.

  • Fragment and compute shaders can read these render pass attachments at any location within the tile. Compute shaders can also write to color attachments at any location within the tile.

  • Shaders can use new built-in variables that provide the location, size, and apron region of the tile.

  • A new tile dispatch command automatically scales workgroup sizes and counts to the tile size, given a desired shading rate.

  • Framebuffer-local dependencies are expanded to tile-sized regions, rather than a single pixel or sample.

  • A tile shading render pass can also enable tiling “aprons”. This is a specialized rendering mode where the GPU renders overlapping tiles that enable specific use cases.

New Commands

New Structures

New Enums

New Bitmasks

New Enum Constants

New or Modified Built-In Variables

New SPIR-V Capabilities

Issues

1) Some early Adreno drivers advertised support for version 1 of this extension without supporting the required tileShadingApron feature. To cover all Adreno devices on the market, applications should not assume any version of this extension supports the tileShadingApron feature without performing a feature query.

Version History

  • Revision 2, 2025-08-13 (Matthew Netsch)

    • Make the tileShadingApron feature optional

  • Revision 1, 2023-10-12 (Jeff Leger)

See Also

No cross-references are available

Document Notes

For more information, see the Vulkan Specification.

This page is a generated document. Fixes and changes should be made to the generator scripts, not directly.

  • 10 types
  • 3 values
  • Packagevulkan-3.27
  • Exports17
  • LanguageGHC2021
  • LicenceBSD-3-Clause
  • SourceVK_QCOM_tile_shading.hs
valuecmdDispatchTileQCOM
  1. :: MonadIO io
  2. => CommandBuffer

    commandBuffer is the command buffer into which the command will be recorded.

  3. -> DispatchTileInfoQCOM

    pDispatchTileInfo is a pointer to a DispatchTileInfoQCOM structure containing information about the area-based dispatch.

  4. -> io ()
#

vkCmdDispatchTileQCOM - Dispatch per-tile work items

Description

This command operates in the per-tile execution model, invoking a separate dispatch for each covered tile. The global workgroup count and local workgroup size of each dispatch are defined by the implementation to efficiently iterate over a uniform grid of pixel blocks within the area of its active tile.

Each shader invocation operates on a single pixel block and its size is determined by the shader’s tiling rate, which must be defined by shaders executed by this command. The TileShadingRateQCOM execution mode operand defines the shader’s tiling rate. Its x and y must be a power of two and less than or equal to the maxTileShadingRate limit. Its z must be less than or equal to the active tile’s depth as reported by VK_QCOM_tile_properties, and TilePropertiesQCOM.tileSize.z % TileShadingRateQCOM::z must equal 0.

The start location of the shader invocation’s pixel block is vec3(TileOffsetQCOM, 0) + (GlobalInvocationId * TileShadingRateQCOM)

Shader invocations can perform tile attachment load/store operations at any location within the active tile, but the most efficient access may be limited to fragment locations within and local to the shader invocation’s pixel block.

Valid Usage

Valid Usage (Implicit)

  • pDispatchTileInfo must be a valid pointer to a valid DispatchTileInfoQCOM structure

  • commandBuffer must be in the recording state

  • The CommandPool that commandBuffer was allocated from must support QUEUE_COMPUTE_BIT operations

  • This command must only be called inside of a render pass instance

  • This command must not be called between suspended render pass instances

  • This command must only be called outside of a video coding scope

Host Synchronization

  • Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels

Render Pass Scope

Video Coding Scope

Supported Queue Types

Command Type

Primary Secondary

Inside

Outside

VK_QUEUE_COMPUTE_BIT

Action

Conditional Rendering

vkCmdDispatchTileQCOM is affected by conditional rendering

See Also

VK_QCOM_tile_shading, CommandBuffer, DispatchTileInfoQCOM

valuecmdBeginPerTileExecutionQCOM
  1. :: MonadIO io
  2. => CommandBuffer

    commandBuffer is the command buffer in which to record the command.

  3. -> PerTileBeginInfoQCOM

    pPerTileBeginInfo is a pointer to a PerTileBeginInfoQCOM structure containing information about how the per-tile execution model is started.

  4. -> io ()
#

vkCmdBeginPerTileExecutionQCOM - Begin per-tile execution mode

Description

When per-tile execution model is enabled, recorded vkCmdDraw* or vkCmdDispatch* commands are invoked per tile. That is, the recorded draw or dispatch is invoked exactly once for each covered tile. The set of covered tiles for a given render pass instance consists of the set of render pass tiles, which can be queried with VK_QCOM_tile_properties, that are completely or partially covered by the renderArea for the render pass instance. The draw or dispatch commands may be invoked for uncovered tiles.

Each per-tile command invocation is associated with a single tile, the active tile. These per-tile invocations are not specified to execute in any particular order, but the size and offset of the active tile is available via shader built-ins.

When per-tile execution model is enabled, the following restrictions apply:

Valid Usage

Valid Usage (Implicit)

Host Synchronization

  • Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels

Render Pass Scope

Video Coding Scope

Supported Queue Types

Command Type

Primary Secondary

Inside

Outside

VK_QUEUE_COMPUTE_BIT VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdBeginPerTileExecutionQCOM is not affected by conditional rendering

See Also

VK_QCOM_tile_shading, CommandBuffer, PerTileBeginInfoQCOM

valuecmdEndPerTileExecutionQCOM
  1. :: MonadIO io
  2. => CommandBuffer

    commandBuffer is the command buffer in which to record the command.

  3. -> PerTileEndInfoQCOM

    pPerTileEndInfo is a pointer to a PerTileEndInfoQCOM structure containing information about how the per-tile execution model is ended.

  4. -> io ()
#

vkCmdEndPerTileExecutionQCOM - End per-tile execution mode

Description

This command disables per-tile execution model.

Valid Usage

  • The /per-tile execution model must/ have been enabled in the current render pass

Valid Usage (Implicit)

Host Synchronization

  • Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels

Render Pass Scope

Video Coding Scope

Supported Queue Types

Command Type

Primary Secondary

Inside

Outside

VK_QUEUE_COMPUTE_BIT VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdEndPerTileExecutionQCOM is not affected by conditional rendering

See Also

VK_QCOM_tile_shading, CommandBuffer, PerTileEndInfoQCOM

VkPhysicalDeviceTileShadingFeaturesQCOM - Structure describing tile shading features that can be supported by an implementation

Members

This structure describes the following features:

Description

If the PhysicalDeviceTileShadingFeaturesQCOM structure is included in the pNext chain of the PhysicalDeviceFeatures2 structure passed to getPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. If the application wishes to use a Device with any features described by PhysicalDeviceTileShadingFeaturesQCOM, it must add an instance of the structure, with the desired feature members set to TRUE, to the pNext chain of DeviceCreateInfo when creating the Device.

Structure Chaining

Extends the structures

See Also

VK_QCOM_tile_shading, Bool32, StructureType

Constructors

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero

VkPhysicalDeviceTileShadingPropertiesQCOM - Structure describing properties supported by VK_QCOM_tile_shading

Description

If the PhysicalDeviceTileShadingPropertiesQCOM structure is included in the pNext chain of the PhysicalDeviceProperties2 structure passed to getPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Structure Chaining

Extends the structure

See Also

VK_QCOM_tile_shading, Bool32, Extent2D, StructureType

Constructors

Instances5Show, Storable, FromCStruct, ToCStruct, Zero

VkRenderPassTileShadingCreateInfoQCOM - Structure specifying, tile shading information for a render pass object.

Description

If this structure is not present, the render pass will have flags set to 0 and tileApronSize is set to (0,0).

Valid Usage

Valid Usage (Implicit)

Structure Chaining

Extends the structures

See Also

VK_QCOM_tile_shading, Extent2D, StructureType, TileShadingRenderPassFlagsQCOM

Constructors

Instances5Show, Storable, FromCStruct, ToCStruct, Zero
datadata PerTileBeginInfoQCOM
#

VkPerTileBeginInfoQCOM - Structure specifying per-tile begin information

Valid Usage (Implicit)

See Also

VK_QCOM_tile_shading, StructureType, cmdBeginPerTileExecutionQCOM

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata PerTileEndInfoQCOM
#

VkPerTileEndInfoQCOM - Structure specifying per-tile end information

Valid Usage (Implicit)

See Also

VK_QCOM_tile_shading, StructureType, cmdEndPerTileExecutionQCOM

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata DispatchTileInfoQCOM
#

VkDispatchTileInfoQCOM - Structure specifying dispatch tile info

Valid Usage (Implicit)

See Also

VK_QCOM_tile_shading, StructureType, cmdDispatchTileQCOM

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero

VkTileShadingRenderPassFlagBitsQCOM - Bitmask specifying flags for tile shading

Description

See Also

VK_QCOM_tile_shading, TileShadingRenderPassFlagsQCOM

Instances8Eq, Ord, Read, Show, Bits, FiniteBits, …