pbr

The engine's standard physically-based material — the full glTF metallic-roughness workflow lit by the shared @builtin::shaderModules.pbr_shading model. This is the default surface shader a model uses when its material doesn't specify another, and it is also registered under the legacy alias standard (the name many materials reference).

It is a surface() shader: it fills a PbrSurface and the engine generates every pipeline entry point and lights it. Every parameter defaults to a neutral value, so a material that sets nothing renders as a clean dielectric; the advanced lobes only cost anything when a material opts into them.

Properties

Emissive authoring

The glow output is emissive × emissive_intensity (× the emissive_texture). The glow colour is emissive, a vec; the intensity over it is emissive_intensity, a scalar. So { emissive = {0.1, 0.9, 1, 1}, emissive_intensity = 5 } is a cyan glow at 5×, and it is these two names that getProperties() lists and setProperty writes.

A spelling another engine's convention uses for the same role — emissive_color, emission, emissive_tint — is resolved onto emissive when the material is authored, so content carried in from glTF, Unity or Godot reaches the property under the name this shader declares. Where two such spellings meet on one of the two names, the shape of each value says which of them it is: a vec is the colour and a number is the intensity, so { emissive_color = {0.2, 0.8, 1, 1}, emissive = 5 } is the same cyan glow at 5x. Two values of one shape are one property's, and the one written under the name the shader declares applies while the other is named in a warning.

A bare positive scalar emissive with no colour beside it is the "turn emission on" shorthand and means a white glow at that intensity, so emissive = 20 on a white material lights up.

The lobes over the base layer

Beyond metallic-roughness, the shading model carries six layers this material declares. Each is gated on its own neutral value, so a material that sets none of them shades as a plain dielectric and each one costs only where it is asked for.

All six are evaluated inside the engine's own light loop, once for every light that reaches the surface, so each one is shadowed, attenuated and cone-masked with the base layer it sits over.

An oil-slicked wet surface is iridescence = 1, an iridescence_thickness around 300-500 nm and a low roughness over a dark base_color. Skin is a warm subsurface_color with a subsurface_radius near 0.5. Velvet is a sheen_color at the fabric's own hue over a dark base.

Standing outside the fog

receives_fog = 0 declares that the screen-space fog passes — heightFog and aerialPerspective in @builtin::systems.atmosphere — leave this surface at the colour it shaded to.

The declaration travels to those passes as a per-pixel surface flag written into the alpha of the G-buffer normal (@builtin::shaderModules.surface_flags). Only the deferred G-buffer fragment entry writes that channel, so the declaration reaches the fog from an opaque draw on the deferred path. A draw the renderer sends through the forward fragment entry — every draw on the forward path, and the transparent phase on either path — writes no G-buffer channel to carry it, and its pixels take the fog like any other.

Textures (glTF metallic-roughness set)

Because the engine holds the full PbrSurface, the capture tool's debug passes (albedo / roughness / metallic / AO / emissive / world-normal / shadow / depth / motion) all read real material data.