Class MaterialAbstract

Whether fragments write colour at all (§57); true by default. false draws the material into the depth buffer only — a depth-prepass or an occluder, visible to the depth test and to nothing else.

Whether fragments are tested against the depth buffer (§57); true by default, which is the fixed state the backend sets at initialization.

false draws the material over everything already in the buffer, whatever its depth — the "always front" overlay case §49's depthMode will generalise.

Whether fragments write depth (§57); true by default.

The usual setting for a transparent surface is depthWrite: false with depthTest: true: it is occluded by opaque geometry in front of it but does not occlude the transparent surfaces drawn after it, which is what keeps a stack of blended quads from punching holes in each other.

Stable identity (§57 inherits §83's resource model), assigned at construction from the family-wide monotonic counter and prefixed by the subclass — material-7, lit-material-8, sprite-material-9. Unique within a process, ascending in construction order, never reused.

Pipeline discriminant (§57, §64, §66 sort key 3) — "unlit", "lit", "sprite", and whatever a later family member declares.

A literal string on each subclass, not an instanceof check: the render list picks an item's pipeline with one property load, which is what §64's "compact render items" require and what lets a structurally-typed test double stand in for a material at all.

§57's optional stencil state (§67); undefined by default, which leaves the stencil test disabled — GL's initial state, and the state every frame this engine drew before R-7 ran in.

material.stencil = new StencilState({ func: "equal", ref: 1, writeMask: 0 });
Copy

A plain property, like the four booleans above and unlike Material.opacity, and the F14 rule is satisfied a different way: every field of a StencilState is validated by the class itself, on construction and on every later write, and the class is nominal — its fields are private, so an object literal is not assignable to it. A caller therefore cannot reach the backend with an unchecked comparison name without going through a validating constructor, and this property has nothing left to check.

That is also what keeps it free. The import above is type-only, so a bundle whose scenes never mask does not carry StencilState — masking costs bytes only where it is used, which a validating accessor here would have made impossible (measured 2026-08-11 over four example bundles: 0.62 kB gzip each, which is 42% of what the whole packet costs them).

Like the rest of §57's render state, assigning does not bump Material.version: a backend re-reads it per draw and caches none of it. Mutating the StencilState in place is therefore live too, with no announcement needed — and two materials may share one record, which is how the two passes of one mask stay in step.

A backend that cannot allocate a stencil buffer honours this by drawing without the mask, never by failing the frame (§61) — see @fourjs/render-webgl's RendererOptions.stencil.

Whether this material's fragments are blended with the colour buffer (§57, §66); false by default.

Two consequences, both stated because a flag that quietly did one of them would be the defect this replaced:

1. the backend enables blending for the draw and applies Material.blendMode. With false — the default — blending stays off and the material's alpha is written to the buffer unblended, which is exactly what every scene authored before this flag existed did;
2. §66's sort key 2 places transparent items after opaque ones inside their render layer, so a blended surface composites over what it overlaps instead of racing it in scene order.

Transparency is a property of the material, not of its alpha: an alpha of 0.5 on an opaque material is a deliberate way to write a half-alpha pixel into the framebuffer (for compositing the canvas with the page), and inferring transparent from it would take that away and make an animated alpha change the sort order mid-frame.