Struct PartitionByAsset 

pub struct PartitionByAsset;

partition-by-asset (no options): a PartitionPlan of one part per asset, so a conversion writes each asset on its own (convert_parts with PlannedParts). Each asset root nothing references is a group of its own, in entity order, keyed by its core.source (else its core.name, else asset <index>), with no context: the part is the asset’s closure, and what its passes place from the root (place-assets run in the part’s passes) is its own. Other independent content (loose placements, and placements a selection made, which reference an asset’s parts rather than belong to it: place assets in the part’s passes, not the selection) is one more group, outside assets, counted, written with what it reaches. An asset another asset references is written with that one.

Trait Implementations

impl Clone for PartitionByAsset

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 PartitionByAsset

impl Debug for PartitionByAsset

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

Formats the value using the given formatter.

impl Default for PartitionByAsset

fn default() -> Self

Returns the “default value” for a type.

impl Eq for PartitionByAsset

impl PartialEq for PartitionByAsset

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

Equality operator ==.

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

Inequality operator !=.

impl Pass for PartitionByAsset

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

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

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

Names that must be present before it runs.

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

Names it may add.

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 run(&self, w: &mut World, log: &mut PassLog) -> Result<(), String>

fn options(&self) -> Options

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

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