Struct PartScope 

pub struct PartScope {
    pub roots: BTreeSet<Entity>,
    pub shared: BTreeSet<Entity>,
    pub context: BTreeSet<Entity>,
    pub whole: bool,
    pub area: Option<[f64; 4]>,
    pub first_made: Option<u32>,
    pub placed: BTreeMap<Entity, bool>,
}

core.part_scope: which entities of a part the conversion writes (its roots, and what they reach) and which it only loaded as context, for passes that make content per source entity. Put in the part’s world before its passes and taken out before writing.

Fields

roots: BTreeSet<Entity>

shared: BTreeSet<Entity>

The part’s Part::shared: output with the roots, owned by another part.

context: BTreeSet<Entity>

whole: bool

The part’s Part::whole: whether it is the whole of what is written.

area: Option<[f64; 4]>

The part’s Part::area: the ground area its context covers, if its source states one.

first_made: Option<u32>

The first entity index the part’s passes make (World::next_index as loaded): an entity below it was loaded (its id is the planning world’s, the same in every part); one at or above it was made in this part. Set by the conversion; None in a scope composed by hand (every entity taken as loaded).

placed: BTreeMap<Entity, bool>

What the part’s passes declared as its output so far (crate::pass::PassLog::place): true, the part’s own (placed with no source, or from an entity in the roots’ closure when it was placed); false, placed from an entity it only loaded as context or shares (crate::pass::PassLog::place_from: that part’s). Classified when declared, so a source a later pass removes does not change it. The pass manager adds each pass’s declarations after it runs (PartScope::declare); empty in a scope composed by hand.

Implementations

impl PartScope

pub fn output(&self, w: &World) -> PartOutput

The part’s output in w: the closure of its roots, of what it shares and of what its passes placed, but for what they placed from an entity it does not own (its context’s or a shared entity’s: that part’s). Context is not output unless the output reaches it; what the passes made and did not place is not output unless it reaches it. The one rule: the conversion writes it, and a pass that needs what a part owns (a summary of its content) asks it.

pub fn owned(&self, w: &World) -> BTreeSet<Entity>

What the part owns in w now: the closure of its roots and of what its passes declared as its own, but for what it shares (another part’s, also where something it owns reaches it).

pub fn declare( w: &mut World, placed: &BTreeSet<Entity>, placed_from: &BTreeMap<Entity, Entity>, owned_before: &BTreeSet<Entity>, )

A pass’s declarations (placed, with their sources placed_from) added to w’s part scope, each classified now: the part’s own when placed with no source or from an entity the part owns, else its context’s. The part owns what PartScope::owned gives after the pass, what it gave before the pass (owned_before: a source the pass consumed still counts), and this pass’s own declarations, so a chain of them (placed from one placed from a root) is the part’s whatever their order. Nothing without a scope (a world outside conversion).

Trait Implementations

impl Clone for PartScope

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 PartScope

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

Formats the value using the given formatter.

impl PartialEq for PartScope

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

Equality operator ==.

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

Inequality operator !=.

impl Resource for PartScope

const NAME: &'static str = "core.part_scope"

fn references(&self, out: &mut Vec<Entity>)

The entities this resource refers to, appended to out. A resource holding entity references must declare every one of them and implement Resource::retain_references.

fn retain_references(&mut self, keep: &dyn Fn(Entity) -> bool)

Forget every reference to an entity keep refuses (set it to “none”). The world calls it whenever entities leave it (World::despawn, World::retain, World::move_components) and on the copy a World::subset or World::split_off part gets, so a resource never refers to an entity its world lacks.

const VERSION: u32 = 1

fn to_json(&self) -> Result<Option<Value>, JsonError>

As Component::to_json.

fn verify(&self, _w: &World) -> Result<(), String>

The resource’s own invariants in w; as Component::verify, run by the pass manager’s verifier.

impl StructuralPartialEq for PartScope