Struct Ops 

pub struct Ops {
    pub root: Option<Vec<f32>>,
    pub bones: Vec<Bone>,
    pub draws: Vec<Draw>,
    pub disguise: Option<String>,
    pub hide: bool,
    pub captures: Vec<String>,
}

A mod’s answer — every handler’s add up, in order.

Fields

root: Option<Vec<f32>>

The whole body’s turn in entity space (after the body’s yaw), column-major.

bones: Vec<Bone>

draws: Vec<Draw>

disguise: Option<String>

Drawn as one of this entity type instead.

hide: bool

The entity itself isn’t drawn (its model, layers and name).

captures: Vec<String>

Sources to capture for the next frame.

Implementations

impl Ops

pub fn is_empty(&self) -> bool

pub fn root(&mut self, m: &Mat4)

Turns the whole body by m in entity space (after the body’s yaw).

pub fn bone(&mut self, bone: &str, op: &BoneOp)

Poses the vanilla part bone (after vanilla animated it).

pub fn mesh( &mut self, anchor: &Anchor, texture: &str, look: Look, quads: &[Quad], )

Draws quads with texture at anchor, looking look.

pub fn disguise(&mut self, entity_type: &str)

Draws the entity as one of entity_type, animated like it.

pub fn hide(&mut self)

Doesn’t draw the entity itself (its model, layers and name).

pub fn capture(&mut self, source: &str)

Asks for the posed geometry of the entity ("self") or of a type posed like it; it comes in the next frame’s Frame::captures.

pub fn add(&mut self, other: Ops)

other’s ops after these (another handler’s): turns compose, the rest adds up, a later disguise wins.

Trait Implementations

impl Clone for Ops

fn clone(&self) -> Ops

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ops

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

Formats the value using the given formatter.

impl Default for Ops

fn default() -> Ops

Returns the “default value” for a type.

impl Fields for Ops

const FIELDS: &'static [(&'static str, &'static str)]

impl PartialEq for Ops

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

Equality operator ==.

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

Inequality operator !=.

impl Schema for Ops

fn encode(&self, __yog_w: &mut Writer)

Writes itself in the binary form, straight — Schema::write’s value encoded, unless the type knows better (derived ones do).

fn decode(__yog_d: &mut Decoder<'_>) -> Option<Ops>

Reads itself from the binary form, straight; None when it isn’t what Schema::encode writes — then read_bytes reads the slow way, which says what’s wrong. Through a value unless the type knows better (derived ones do).

fn pack(&self, __yog_p: &mut Packer)

Packs itself into a frame (crate::frame): its binary form as bytes, unless the type packs itself (derived ones and plain types do).

fn unpack(__yog_u: &mut Unpacker<'_>) -> Option<Ops>

Reads itself out of a frame; None if the bytes aren’t what Schema::pack writes.

fn shape() -> Shape

What the format looks like.

fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<Ops>

Reads v. Problems go to cx at its current path; None when the value couldn’t be read (the problem is in cx).

fn write(&self) -> Value

The value, as the format writes it.

fn absent() -> Option<Self>

The value of a field that isn’t there — None: the field is required.

fn skip(&self) -> bool

Whether a struct leaves this field out when writing it.

fn pack_list(items: &[Self], p: &mut Packer)

A list of these packed: a count, then each one (floats raw).

fn unpack_list(u: &mut Unpacker<'_>) -> Option<Vec<Self>>

A list of these out of a frame.

fn encode_list(items: &[Self], w: &mut Writer)

A list of these written straight (numbers pack theirs).

fn decode_list(d: &mut Decoder<'_>) -> Option<Vec<Self>>

A list of these read straight.

impl StructuralPartialEq for Ops