Struct ParticleSkin 

pub struct ParticleSkin { /* private fields */ }

A particle cloud’s attachment to a skeleton.

Built once from the cloud’s rest positions and reused for every frame after that. Holds one Bind per particle and nothing else: the rest positions stay with the caller, because the caller already has them and copying a hundred thousand of them twice would be the most expensive thing here.

Implementations

impl ParticleSkin

pub fn new() -> ParticleSkin

An empty skin.

pub fn len(&self) -> usize

How many particles this skin covers.

pub fn is_empty(&self) -> bool

pub fn bind_of(&self, i: usize) -> Option<Bind>

The binding for one particle.

pub fn from_binds(binds: Vec<Bind>) -> ParticleSkin

Build a skin from explicit bindings.

pub fn bind_nearest( points: &[Vec3], skeleton: &Skeleton, falloff: f32, ) -> ParticleSkin

Attach every point to the bones nearest it.

points are in the skeleton’s bind-pose space. falloff is how far beyond the closest bone a second bone may be and still take a share of the particle, in the same units as the points: it is the width of the soft band around each joint, so a value near a limb’s thickness gives a joint that bends and a value of zero gives a rigid, shearing one.

Bones with no children still bind — a hand, a head, the end of a tail — using a short stub along the direction they came from, so the tip of a limb is not left orphaned to whatever happens to be nearest.

pub fn bind_grouped( points: &[Vec3], skeleton: &Skeleton, falloff: f32, groups: &[u16], group_bones: &[Vec<BoneId>], ) -> ParticleSkin

Attach every point to the nearest of the bones it is allowed to use.

Proximity on its own is not enough for a cloud that was sculpted rather than modelled. A figure holding a two-handed sword has the blade up beside its head at rest, so the nearest bone to most of the weapon is the skull: bind by distance alone and swinging the arm leaves the sword behind while nodding drags it around. The caller knows which parts of the sculpt are the weapon, the cloak, the legs — that knowledge is what groups carries.

groups[i] names which entry of group_bones point i may bind to. A group that is empty, or an index past the end, falls back to the whole skeleton, so a caller that forgets to classify something still gets a particle that moves with the body rather than one left in mid-air.

pub fn apply( &self, skeleton: &Skeleton, pose: &Pose, rest: &[Vec3], out: &mut Vec<Vec3>, )

Move a cloud into a pose.

rest are the same points the skin was bound from and out receives the posed positions; out is resized to match. Both may be the same length as the skin or shorter — a cloud that has grown since it was bound leaves its extra particles where they are rather than panicking, because a figure gaining matter mid-animation is a real thing that happens here and is not worth crashing over.

Linear blend skinning: the classic artefact is that a joint under heavy twist loses volume. At the scale one particle occupies that is not visible, and the springs downstream hide what is left of it.

pub fn apply_with(&self, matrices: &[Mat4], rest: &[Vec3], out: &mut Vec<Vec3>)

The same, against matrices the caller already has.

Building the matrices walks the whole hierarchy and inverts a matrix per bone. That is nothing next to skinning a hundred thousand particles, but it is pure waste when positions and normals are both being skinned against the same pose — which is every frame, for every figure.

pub fn skin_one(p: Vec3, bind: &Bind, matrices: &[Mat4]) -> Vec3

Where one point goes, given the skinning matrices for a pose.

Exposed because a caller often needs a single position — where a hand is, so an effect can be thrown from it — without posing the whole cloud.

pub fn apply_normals( &self, skeleton: &Skeleton, pose: &Pose, rest: &[Vec3], out: &mut Vec<Vec3>, )

Turn a cloud’s surface normals to match a pose.

Lighting here is per particle against a real normal, so a normal left pointing where the bone used to be is an arm that bends while its shading stays behind — which reads as the limb going flat exactly when it moves. Uses the dominant bone rather than blending: a normal is a direction, blending two of them needs a renormalise, and across a joint the difference is a fraction of a degree on a particle a few pixels wide.

pub fn apply_normals_with( &self, matrices: &[Mat4], rest: &[Vec3], out: &mut Vec<Vec3>, )

The same, against matrices the caller already has.

pub fn skinning_matrices(skeleton: &Skeleton, pose: &Pose) -> Vec<Mat4>

The matrices that take a point from bind space to posed space.

One per bone, in bone-index order. Split out so a caller posing several clouds against the same skeleton computes them once.

Trait Implementations

impl Clone for ParticleSkin

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 ParticleSkin

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

Formats the value using the given formatter.

impl Default for ParticleSkin

fn default() -> Self

Returns the “default value” for a type.