GPU Shader Programs

Bind stock shader programs, configure vertex layouts, and supply draw constants.

Ultralight uses seven shader programs to render geometry. Each program pairs a vertex shader with a pixel shader, and the SDK ships precompiled files and source headers for every supported graphics API.

On each draw, your driver binds the requested program and supplies vertices, uniforms, and textures in the format the shaders expect. If you're building on the reference drivers in the SDK's platform folder, they already handle these steps.

#Binding Shader Programs

Each draw command specifies its program in GPUState::shader_type. Your driver binds the matching vertex and pixel shader pair before drawing, typically inside a state helper such as MyGPUDriver::ApplyState() from Implementing a GPUDriver.

A conforming driver must support every program in the table— the library doesn't query for per-program support, though it checks other capabilities through GetDeviceCaps().

#Configuring Vertex Layouts

The renderer provides geometry through vertex buffers described by VertexBuffer::format. Each format corresponds to a packed struct with no padding.

Positions use pixel coordinates. The obj field holds object-space coordinates used for anti-aliasing in path and quad geometry.

Although named an instance layout, Vertex_2f_2ui uses standard indexed draw calls without hardware instancing APIs.

🚧 Bind Integer Attributes

The header_addr and path_slot fields in Vertex_2f_2ui are unsigned 32-bit integers. Bind them through the integer attribute path in the graphics API (eg, glVertexAttribIPointer or an R32_UINT input element)— treating them as floating-point attributes causes the GPU to misread their values silently.

#Updating the Constant Block

Populate an 800-byte uniform buffer at register 0 for both shader stages using data from GPUState:

///
/// The constant block the stock shaders read, filled from GPUState.
///
struct Uniforms {
  float state[4];         // 0, viewport width, viewport height, 1
  Matrix4x4 transform;    // GPUState::transform times the projection
  int32_t integer[8];     // GPUState::uniform_integer
  float scalar[8];        // GPUState::uniform_scalar
  vec4 vector[8];         // GPUState::uniform_vector
  int32_t clip_size[4];   // x = GPUState::clip_size, the rest 0
  Matrix4x4 clip[8];      // GPUState::clip
};

Copy the matrix data from GPUState::clip directly into the buffer. For the transform field, multiply GPUState::transform by the projection matrix, as described in Implementing a GPUDriver.

#Binding Texture Slots

The driver binds textures from GPUState::texture_1_id through texture_3_id to registers 0 through 2, skipping any slot set to 0.

For vector draws with FillPhoton and FillPhotonGrid, the renderer passes raw data pages rather than sampled images. The shaders read these textures directly through texel loads, leaving slot 2 unused.

Configure data page textures without filtering or mipmaps. The index page requires an unsigned integer texture view with its own register— it must not share a binding point with floating-point views.

When drawing with FillPhotonGrid, bind the data page textures to both the vertex and pixel shader stages.

#Shipped Shaders

The SDK provides stock shaders under platform/shaders/generated/ in formats tailored for each graphics backend.

#SPIR-V Descriptor Bindings

The precompiled SPIR-V shaders place every resource into descriptor set 0 and share a single layout— one descriptor set layout serves every pipeline. Textures bind as separate sampled images, and a single sampler descriptor sits at binding 16.