Enum ssbh_lib::formats::skel::Skel

pub enum Skel {
    V10 {
        bone_entries: SsbhArray<SkelBoneEntry>,
        world_transforms: SsbhArray<Matrix4x4>,
        inv_world_transforms: SsbhArray<Matrix4x4>,
        transforms: SsbhArray<Matrix4x4>,
        inv_transforms: SsbhArray<Matrix4x4>,
    },
}

An ordered, hierarchical collection of bones and their associated transforms. Each bone entry has transformation matrices stored at the corresponding locations in the transform arrays. The transforms array can be used to calculate the remaining arrays. Compatible with file version 1.0.

Variants

V10

Fields

bone_entries: SsbhArray<SkelBoneEntry>

A skeleton consisting of an ordered hierarchy of bones.

world_transforms: SsbhArray<Matrix4x4>

The transformation in world space for each bone in bone_entries. The world space transform for a bone is calculated by accumulating the transformations in transforms with the transformation of the bone’s parent recursively.

inv_world_transforms: SsbhArray<Matrix4x4>

The inverses of the matrices in world_transforms.

transforms: SsbhArray<Matrix4x4>

The associated transformation for each of the bones in bone_entries relative to its parent’s world transform. If the bone has no parent, this is equivalent to the corresponding value in world_transforms.

inv_transforms: SsbhArray<Matrix4x4>

The inverses of the matrices in transforms.

Implementations

impl Skel

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, ReadSsbhError>

Tries to read the current SSBH type from path. The entire file is buffered for performance.

pub fn read<R: Read + Seek>(reader: &mut R) -> Result<Self, ReadSsbhError>

Tries to read the current SSBH type from reader. For best performance when opening from a file, use from_file instead.

pub fn write<W: Write + Seek>(&self, writer: &mut W) -> Result<()>

Tries to write the SSBH type to writer. For best performance when writing to a file, use write_to_file instead.

pub fn write_to_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Tries to write the current SSBH type to path. The entire file is buffered for performance.

Trait Implementations

impl BinRead for Skel

type Args<'__binrw_generated_args_lifetime> = (u16, u16)

The type used for the args parameter of read_args() and read_options().

fn read_options<R: Read + Seek>( __binrw_generated_var_reader: &mut R, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_> ) -> BinResult<Self>

Read Self from the reader using the given Endian and arguments.

fn read_be<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming big-endian byte order.

fn read_le<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming little-endian byte order.

fn read_ne<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read T from the reader assuming native-endian byte order.

fn read_be_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming big-endian byte order, using the given arguments.

fn read_le_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming little-endian byte order, using the given arguments.

fn read_ne_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read T from the reader, assuming native-endian byte order, using the given arguments.

impl Clone for Skel

fn clone(&self) -> Skel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Skel

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

Formats the value using the given formatter.

impl PartialEq for Skel

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl SsbhWrite for Skel

fn ssbh_write<W: Write + Seek>( &self, writer: &mut W, data_ptr: &mut u64 ) -> Result<()>

Writes the byte representation of self to writer. data_ptr is assumed to be the absolute offset where the next data stored behind an offset will be written. Struct that contains no offsets as fields can skip updating data_ptr.

fn size_in_bytes(&self) -> u64

The offset in bytes between successive elements in an array of this type. This should include any alignment or padding.

fn alignment_in_bytes() -> u64

The alignment for pointers of this type, which is useful for offset calculations.

fn write<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek,

Writes the byte representation of self to writer. This is a convenience method for ssbh_write that handles initializing the data pointer.

impl Version for Skel

fn major_minor_version(&self) -> (u16, u16)

impl StructuralPartialEq for Skel