Struct DropOptional 

pub struct DropOptional {
    pub max: u8,
}

drop-optional{max=N}: every placement more optional than max (its Priority above it) is despawned with everything it holds, counted per priority; the others are untouched. Without options max is 255 and nothing is dropped: leaving placements out is always a pipeline’s explicit choice. A dropped entity that a kept one refers to (a self-placed mesh other placements use as their prototype) is refused, and nothing is dropped.

Fields

max: u8

Trait Implementations

impl Clone for DropOptional

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 DropOptional

impl Debug for DropOptional

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

Formats the value using the given formatter.

impl Default for DropOptional

fn default() -> Self

Returns the “default value” for a type.

impl Eq for DropOptional

impl PartialEq for DropOptional

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

Equality operator ==.

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

Inequality operator !=.

impl Pass for DropOptional

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

Names it may take away (what it lowers).

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