Enum ProgramFrame 

pub enum ProgramFrame {
    Source(SourceFrame),
    NotConverted {
        why: String,
    },
}

core.program_frame: the coordinate frame the source’s game programs compute in, stated by the reader that keeps them. The world is in core’s frame (crate::frame); a source’s programs compute in the frame their game’s data is in, which its reader converted the world out of. A consumer that runs them on the world converts every value they read into their frame by its kind (SpatialKind) and reads what they write in it, so the programs compute as they do in the game. There is no default: a reader states one form or the other, an identity included (Source(SourceFrame::WORLD) for programs that compute in core’s frame).

Variants

Source(SourceFrame)

The programs compute in this frame: world = frame(program), as the reader converted the source’s data.

NotConverted

The frame the programs compute in is not established for this source, or a consumer’s conversion into it is not checked: a consumer feeds them world values unconverted and shows why with every view of them. why names the world, what is known of its frame and on what evidence, and what is missing.

Fields

why: String

The world, what is known of its programs’ frame (with its evidence), and what is not.

Implementations

impl ProgramFrame

pub fn frame(&self) -> Option<&SourceFrame>

The frame values are converted into, where one is stated.

pub fn state(self, world: &mut World) -> Result<(), String>

State this as the world’s program frame, from a reader or pass that keeps the source’s programs: inserted where the world has none, kept where it has the same, refused where it has another (two producers of one world’s programs disagreeing on the frame they compute in).

Trait Implementations

impl Clone for ProgramFrame

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 ProgramFrame

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

Formats the value using the given formatter.

impl PartialEq for ProgramFrame

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

Equality operator ==.

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

Inequality operator !=.

impl Resource for ProgramFrame

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

A frame that is not converted says why.

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

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

As Component::to_json.

const VERSION: u32 = 1

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.

impl StructuralPartialEq for ProgramFrame