Struct LitVariant 

pub struct LitVariant {
    pub options: Hashed<LitOptions>,
    pub surface: SurfaceKey,
    pub channels: LitVertexChannels,
    pub base_color_texture: bool,
    pub morph: bool,
    pub strip_index_format: Option<IndexFormat>,
}

The complete identity of a built-in lit pipeline, and its blueprint.

A family resolves one from an entity’s LitOptions and the facts its draw carries: the mesh’s vertex channels, whether the draw binds a material, whether the mesh morphs, the mesh’s index format and the render target. Two draws that agree on all of it share one compiled pipeline; because the variant is the complete description of the blueprint, the cache key is canonical by construction.

Fields

options: Hashed<LitOptions>

The caller’s policy, with its hash computed once. The variant is the cache key, so the stored word is what every per-frame lookup hashes; rewrite the policy through Hashed::update rather than the value itself, so the word follows the change.

surface: SurfaceKey

The render target the pipeline is built for.

channels: LitVertexChannels

The per-vertex channels the mesh’s layout carries.

base_color_texture: bool

Whether the draw binds a material group and so samples a base-color texture.

morph: bool

Whether the mesh carries morph displacements.

strip_index_format: Option<IndexFormat>

The strip index format the mesh’s index buffer requires, if any.

Implementations

impl LitVariant

fn features(&self, texel_arrays: bool) -> [(&'static str, bool); 17]

The WESL @if features the variant asks for, paired with their state.

Every name appears, so the composed variant never sees a name it does not know. The per-vertex names come from Self::channels, the material one from Self::base_color_texture and the policy ones from Self::options. The per-instance record is not conditional at all, so it contributes no names here: the built-in vertex stream always declares and binds an instance buffer.

texel_arrays is the device’s answer rather than the variant’s, so it is passed in from the caller that read the device.

pub fn needs_joints(&self) -> bool

Whether the variant deforms its vertices by joint matrices and so reads the global group’s array of them.

pub fn needs_morphs(&self) -> bool

Whether the variant reads the global group’s morph arrays: the per-instance weights and the per-mesh displacements.

pub fn needs_metadata(&self) -> bool

Whether the variant reads the global group’s mesh-metadata array: the per-mesh decode parameters and the addressing a morph reads.

Mirrors the shader’s metadata condition, so the layout and the composed variant agree on whether the binding exists. A morph needs the array even when every channel is uncompressed, because the struct also carries the vertex offset and morph count its displacements are addressed by.

pub fn secondary_stream(&self) -> SecondaryStreamWriter

The secondary vertex stream this variant expects.

The stream is described in crate::mesh’s own terms: this variant’s channels are translated into the ones that make up a vertex stream, so packing meshes for this pipeline needs nothing specific to it.

pub fn position_stream(&self) -> PositionStreamWriter

The position vertex stream this variant expects.

The joint indices and weights the variant deforms with belong to this stream rather than one of their own, so a skinned variant’s stream is wider by the joint pair and nothing else changes.

fn assert_device_supports_arrays(&self, device: &Device, texel_arrays: bool)

Reject a variant whose array path the device cannot serve.

The texel path works on every device — a texture read is universal — so forcing it on a device that also has storage buffers is allowed. The reverse is not: a bind-group layout naming a storage buffer is rejected outright by a device without them, so the failure is caught here with the reason rather than left to wgpu’s validation.

A variant that declares no array binding at all — the UI’s, which reads only full-precision vertex attributes — has nothing to serve either way, so it is not asked to pick a path.

Panics

If the variant reads storage buffers on a device that has none.

impl LitVariant

pub fn bind_group_layouts(&self, device: &Device) -> LitBindGroupLayouts

Build the bind-group layouts this variant declares, without compiling the pipeline.

The layouts come from the same variant a pipeline is built from, so the two agree: the global group always exists, and the material group only for a variant that samples a base-color texture. The mesh group is always None — the built-in variants bind nothing there.

The array path is the device’s answer rather than the variant’s, so it is read here: a cache is built for one device, which is why the path never enters the variant key.

pub fn vertex_buffer_layouts(&self) -> [Option<VertexBufferLayoutDesc>; 3]

The vertex-buffer declarations the built-in shader expects, in slot order.

The first two slots follow the variant’s channels; the third is always the instance stream, which every built-in variant binds. A slot whose variant declares no attributes is reported as None, so a variant never binds a buffer the shader does not declare.

fn instance_layout(&self) -> VertexBufferLayoutDesc

The instance stream every built-in variant expects.

One record layout serves every variant of a frame — the source uploads a single &[MeshInstance] buffer and binds it at INSTANCE_SLOT for every draw — so the stride is always the whole MeshInstance. The declared attributes mirror the shader’s own input declarations: the model matrix, the base color, the pose bases and the metadata index unconditionally, the alpha cutoff and the hull width under the features that declare them. A pipeline never declares an attribute the shader does not, which the validation layers would otherwise flag on every draw.

Trait Implementations

impl Clone for LitVariant

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LitVariant

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LitVariant

impl Hash for LitVariant

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LitVariant

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PipelineDescriptor<RenderPipeline> for LitVariant

fn create(&self, device: &Device) -> RenderPipeline

Compose this variant’s entry shader and build the pipeline, so a variant compiles through the same PipelineDescriptor mechanism a caller’s own descriptor does.

The entry shader is the built-in lit.wesl, with the options’ own snippets (LitOptions::shader) spliced into it at its marks.

impl PipelineVariant<RenderPipeline> for LitVariant

type Descriptor = LitVariant

The blueprint this variant compiles.

fn descriptor(&self, _device: &Device) -> Self

Build this variant’s blueprint. Called only on a cache miss.

impl StructuralPartialEq for LitVariant