glTF Depth Write State Across Alpha Modes

The glTF specification defines three alpha modes—OPAQUE, MASK, and BLEND—each dictating how surface transparency interacts with the graphics rendering pipeline. The depth write state (glDepthMask in OpenGL or depthWrite in standard WebGL frameworks) controls whether rendered pixels update the Z-buffer, directly impacting visibility, occlusion, and rendering order. When toggling between these alpha modes at runtime without synchronizing the depth write state, applications encounter visual artifacts such as missing background geometry, sorting anomalies, or depth fighting.

Expected Depth Write States per glTF Alpha Mode

To maintain visual accuracy, graphics engines assign distinct depth write behaviors to each glTF alpha mode:

  • OPAQUE: Depth write is enabled (depthWrite = true). Fully opaque surfaces write their fragment depth to the Z-buffer. This allows subsequent fragments further away from the camera to be rejected via early or late depth testing.
  • MASK: Depth write is enabled (depthWrite = true). Alpha values are tested against a defined cutoff threshold (alphaCutoff). Fragments failing the test are discarded completely, while passing fragments write to the depth buffer as standard opaque pixels.
  • BLEND: Depth write is typically disabled (depthWrite = false). Fragments are blended with background pixels using traditional alpha blending equations. Because blending requires visibility of objects behind the current surface, writing to the depth buffer is suppressed to prevent early depth-test rejections of subsequent background fragments.

The Impact of Toggling Modes

Dynamic material changes—such as transitioning an object from opaque to transparent or enabling cutouts—modify how fragments are handled. Failing to update the depth write state alongside the alpha mode produces significant graphical degradation.

1. Switching to BLEND with Depth Write Enabled

If a material changes from OPAQUE or MASK to BLEND while leaving depth write active, the transparent surface writes its depth into the Z-buffer.

  • Occlusion Artifacts: Any object drawn after the blended surface that lies spatially behind it will fail the depth test. Consequently, background geometry becomes invisible through the translucent surface, creating artificial "holes" in the scene.
  • Sorting Sensitivity: While drawing transparent meshes back-to-front partially mitigates this, self-overlapping geometry on the same mesh will fail to blend properly, as foreground polygons block background polygons of the same object.

2. Switching to OPAQUE or MASK with Depth Write Disabled

If a material transitions from BLEND to OPAQUE or MASK while keeping depth write disabled, surfaces render visually opaque but register no presence in the Z-buffer.

  • Incorrect Occlusion: Objects positioned further behind will pass their depth tests and overwrite the supposedly opaque foreground object if drawn later in the render loop.
  • Sorting Failures: The engine loses the ability to perform standard hardware-accelerated occlusion culling, requiring strict front-to-back sorting that is computationally expensive and prone to self-intersection artifacts on complex meshes.

Pipeline and Sorting Considerations

Toggling alpha modes also alters the pipeline requirements for draw call batching and queue management:

  • Queue Migration: Engines group OPAQUE and MASK materials into an opaque pass sorted front-to-back to maximize early-Z performance. BLEND materials must migrate to a transparent pass sorted back-to-front.
  • State Synchronization: Updating the alpha mode property alone in an engine's material definition is insufficient if the underlying pipeline state object (PSO) or material flags do not automatically link depthWrite status to the chosen mode. Explicitly binding depth write status ensures the hardware rasterizer handles occlusion and blending correctly across state transitions.