Struct SelectVariant 

pub struct SelectVariant {
    pub field: String,
    pub value: u32,
}

select-variant{field=NAME,value=N} (both required: the choice is the caller’s): in every ShaderBinding that has stages keyed by field (super::VariantKey), the stages of the variant value stay, without their key, and the stages of the other variants of that field are left out, counted. The binding then holds one stage of each kind under no key, as a consumer that draws one program of a stage reads it. A stage with no key or a key of another field is left as it is; a binding with no stage keyed by field, or none of the value value (a source numbers a binding’s variants from 0, so bindings hold different numbers of them), is left as it is and counted. A value that no binding of the world carries, or a field none uses, is an error naming the fields and values the world does carry, and changes nothing. A program only the stages left out drew (its core.shader entity, which nothing in the world refers to any more) is despawned, counted.

Fields

field: String

value: u32

Trait Implementations

impl Clone for SelectVariant

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 SelectVariant

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

Formats the value using the given formatter.

impl Eq for SelectVariant

impl PartialEq for SelectVariant

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

Equality operator ==.

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

Inequality operator !=.

impl Pass for SelectVariant

fn modifies(&self) -> &[&'static str]

The stages of the other variants are taken out of the binding in place, and the chosen ones lose their key.

fn despawns_entities(&self) -> bool

The programs only the left-out stages drew.

fn name(&self) -> &'static str

Stable name, used in pipelines and reports (load-meshes).

fn options(&self) -> Options

The options this instance was made with (printed into the pipeline).

fn requires(&self) -> &[&'static str]

Names that must be present before it runs.

fn run(&self, w: &mut World, log: &mut PassLog) -> Result<(), String>

fn may_lack_inputs(&self) -> bool

Whether a run may skip it in a world (or a part) that holds none of its required names: a lowering whose input the world may simply not have (a part of only a light has no materials, a read region no lights) opts in; the step is recorded as skipped (StepReport::skipped). Required names are prerequisites, so this is false unless the pass says otherwise: an absent name may be a failed load or a wrong order, and a pass that summarizes, decides or plans never opts in.

fn settings(&self) -> &[Setting]

The run settings it reads, which the program states for the run on its manager (its thread count, crate::parallel::THREADS, PassManager::with_settings): checked with Pass::requires before it runs and refused where absent, never counted in whether it is skipped (Pass::may_lack_inputs), and stated in its step’s report.

fn provides(&self) -> &[&'static str]

Names it may add.

fn removes(&self) -> &[&'static str]

Names it may take away (what it lowers).

fn approximates(&self) -> &'static str

What it approximates, in words (empty when it is exact).

fn removes_by_log(&self) -> bool

Whether the components it removes are not all known in advance (a hook decides, as crate::Component::apply_linear does). If so, a component name that disappears is accepted when the pass recorded it in PassLog::removed as well as when it is declared in Pass::removes; a name that disappears unrecorded and undeclared is an error as ever, and a resource it removes must be declared as for any pass.

fn settles(&self) -> &[&'static str]

Names whose values it brings to their final form (a classifier: every surface classified). A later pass in a pipeline that provides one of them adds values that never went through this pass: unless a pass after it settles the name again, PassManager::run refuses such a pipeline before it runs (Error::SettledThenChanged). Modifying settled values later is allowed. A modifier must not add values without declaring them in Pass::provides; the target’s value rules check the result.

impl StructuralPartialEq for SelectVariant