Struct SelectLod 

pub struct SelectLod {
    pub choice: LodChoice,
}

select-lod{form=finest|default|N} (form required: which level of detail is drawn is the program’s choice): every prototype with Lods is left with the one form Lods::choose takes (with default, the finest where the source authored no default, counted as an approximation). Another form than its own takes the prototype’s own geometry away with everything that describes it (World::remove_mesh: core.mesh, core.mesh_file and every per-primitive component, dialect data included, so nothing describing the discarded form stays behind when the chosen form lacks it), then every component the form holds replaces the prototype’s of that name (World::move_components), so the form’s dialect data travels with it without the pass knowing it, except what stays with the prototype (core.name, core.source, core.collision: the form’s own are left behind, counted); a form that draws nothing leaves the prototype without a mesh. The other forms are despawned and core.lods removed. The whole selection is checked before anything changes: an invalid one (a prototype drawn with another form while it holds an opaque component, which can’t be told to follow, among them) is an error and leaves the world as it was.

Fields

choice: LodChoice

Trait Implementations

impl Clone for SelectLod

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SelectLod

impl Debug for SelectLod

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

Formats the value using the given formatter.

impl Eq for SelectLod

impl PartialEq for SelectLod

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

Equality operator ==.

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

Inequality operator !=.

impl Pass for SelectLod

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

A prototype drawn with another form loses its own mesh and variants (and keeps the form’s).

fn removes_by_log(&self) -> bool

The per-primitive data of a prototype’s own form (World::remove_mesh) is whatever its reader attached; each name taken from a prototype the chosen form doesn’t give back is recorded.

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 modifies(&self) -> &[&'static str]

Names whose values it edits in place, and resources it writes (replaced, also by removing and inserting again, or borrowed with World::resource_mut). The pass manager checks the resources; an in-place edit of a component’s value on an entity that keeps it (get_mut, or World::insert over the value) is declared here and not checked: seeing it would take a controlled editing interface, later work. What the gap costs: a pass that edits a value in place without declaring it here is never named, in any build, and its edit can make what the declarations say about that name wrong (Pipeline::unfed, Pipeline::check); one that leaves an invalid value there is named at the pass in a build with the pass checks, and in a release build without them only by the verifier that runs before the writer, which names the entity but not the pass. Adding a name to an entity, taking one away and despawning are checked entity by entity against Pass::provides, Pass::removes and Pass::despawns_entities.

fn despawns_entities(&self) -> bool

Whether it despawns entities. If so, a component name it does not declare in Pass::removes may disappear when every entity that held the name before the pass was despawned by it (a dropped placement’s core.name, a discarded form’s dialect data); a name still held by a surviving entity before the pass must be declared as ever. Added names are checked as for every pass.

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

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

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 requires(&self) -> &[&'static str]

Names that must be present before it runs.

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 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 SelectLod