Struct GitObjectPlacement 

pub struct GitObjectPlacement {
    pub object_id: Option<ObjectId>,
    pub x_position: f32,
    pub y_position: f32,
    pub z_position: f32,
    pub x_orientation: f32,
    pub y_orientation: f32,
    pub z_orientation: Option<f32>,
}

Where an item entry or a store entry sits, whichever form the entry takes.

One type for two lists rather than one each: the sets are the same, they agree on every audited axis, and the declarations the extraction produced for them are identical. A later measurement that parts them breaks the share rather than quietly answering for the wrong list.

ObjectId is deliberately not here, because it is not shared: every saved form carries it, no static form does, and the party stash carries it on none of its items. It is declared by the saved arms instead, so a list that has no runtime id does not gain one on the way back out.

Fields

object_id: Option<ObjectId>

Runtime object id (ObjectId), which not every list carries.

None where the file has no label, which is the state the six fields below never reach: they are on every element of every list measured and this one is not. Static forms carry it nowhere, and among saved forms the party’s shared stash carries it on none of its items while every other item list carries it on all of theirs.

Held as the absence rather than resolved to a value because writing it back is what the resolution would cost. The engine’s own answer for an absent label is on the schema entry beside this one, and it is INVALID rather than zero.

x_position: f32

X position (XPosition).

y_position: f32

Y position (YPosition).

z_position: f32

Z position (ZPosition).

x_orientation: f32

X orientation (XOrientation).

y_orientation: f32

Y orientation (YOrientation).

z_orientation: Option<f32>

Z orientation (ZOrientation). Z orientation (ZOrientation), which only a saved form carries.

The same two-versus-three split the creature block has: a static item or store placement carries XOrientation and YOrientation and no third, and every saved one carries all three.

Implementations

impl GitObjectPlacement

pub const SCHEMA: [Field; 7]

This view’s schema, one entry per declared field.

pub const PARTS: &'static [&'static [Field]]

This type’s schema in parts, which is what a container holding it references.

Own fields first, then one part per flattened child in the order they are declared.

pub fn read_declared(root: &GffStruct) -> Self

Reads every declared field off root.

Absent fields take the entry’s own answer, so a fallback is derived from the declaration rather than restated beside it.

A field declaring a hand-written read is left at that answer for the view to overwrite.

pub fn write_declared(&self, root: &mut GffStruct)

Writes every declared field onto root, leaving out the ones their entry says the engine’s own writer leaves out.

A field declaring a hand-written write is not touched here.

pub fn read_element(structure: &GffStruct) -> Self

Reads one element of a list of this type.

pub fn write_element(&self, structure: &mut GffStruct)

Writes one element of a list of this type.

Trait Implementations

impl Clone for GitObjectPlacement

fn clone(&self) -> GitObjectPlacement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GitObjectPlacement

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

Formats the value using the given formatter.

impl Default for GitObjectPlacement

fn default() -> Self

What a file omitting every label loads to, which is what makes an authored file land in a known state rather than at zero.

impl HasSchema for GitObjectPlacement

fn schema() -> &'static [Field]

The root field schema for this resource type.

fn parts() -> &'static [&'static [Field]]

The same schema in parts, own fields first.

impl PartialEq for GitObjectPlacement

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for GitObjectPlacement