Struct CharacterShape 

pub struct CharacterShape {
    pub asset_id: AssetId,
    pub target: Option<SkinnedMeshHandle>,
    pub sliders: Vec<ShapeSlider>,
    pub proportions: Vec<JointProportion>,
    pub bake: bool,
}

Shape sliders and joint proportions applied to one SkinnedMesh.

Every characteristic of the shape is data on the mesh, not code: a slider drives one or two of the mesh’s morph targets, and a proportion scales or lengthens one joint of its skeleton. The deformation is static and sits under any Animation playing on the same mesh: clip morph tracks are added on top of the slider weights, and clip poses are re-proportioned every frame.

Sliders resolve to morph targets by name. A target named exactly name is unipolar and receives the slider value clamped to [0, 1]. A pair named name+ / name- is bipolar: a positive value drives name+, a negative value drives name- by its magnitude. A slider with no matching target is reported as a build warning and ignored.

Proportions resolve to joints by name. scale is uniform (the skinning shaders transform normals with the plain joint matrix, so a non-uniform scale would shade incorrectly) and propagates to the joint’s descendants; length moves only the joint’s children along the bone, so a longer thigh does not also stretch the shin. Proportions change the posed skeleton, not the bind pose, so clips with translation tracks on the affected joints fight them; keep such rigs rotation-only. When the mesh declares a capsule, the capsule’s half-height follows the skeleton’s height change and its radius follows the root joint’s scale.

target may name a CharacterModel as well as a SkinnedMesh; the model’s emitted mesh is what the shape deforms.

Baking. With bake set, the build flattens the shape into its target: the sliders’ deformation is applied to the vertices and the morph targets dropped, the bind pose is rewritten through the proportions, the capsule is resized, and this asset is consumed. The result is a plain SkinnedMesh with no per-frame shape work, for characters that never change shape.

CharacterShape {
    sliders: vec![ShapeSlider { name: "weight".into(), value: 0.5 }],
    proportions: vec![JointProportion { joint: "spine".into(), scale: 1.1, length: 0.0 }],
    ..Default::default()
};

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

target: Option<SkinnedMeshHandle>

The SkinnedMesh this shape deforms.

sliders: Vec<ShapeSlider>

Named shape values, each resolved to the mesh’s morph targets.

proportions: Vec<JointProportion>

Per-joint scale and length changes.

bake: bool

Flatten the shape into the target mesh at build time and drop this asset, instead of deforming at runtime.

Implementations

impl CharacterShape

pub fn resolve_sliders(&self, target_names: &[String]) -> ResolvedSliders

Resolve sliders against target_names (the mesh’s morph targets in target order). Several sliders naming the same target accumulate; the result is clamped to [0, 1] per target.

pub fn unresolved_joints(&self, has_joint: impl Fn(&str) -> bool) -> Vec<String>

The proportion joint names that has_joint does not know.

Trait Implementations

impl Clone for CharacterShape

fn clone(&self) -> CharacterShape

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for CharacterShape

const NAME: &'static str = "CharacterShape"

The registry name a world authors this component under.

fn inject_name(&mut self, id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

fn from_baked(bytes: &[u8]) -> Result<Self, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

impl ComponentSlot for CharacterShape

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<Self>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<Self>

Mutably borrow this type’s column out of the storage.

impl Debug for CharacterShape

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

Formats the value using the given formatter.

impl Default for CharacterShape

fn default() -> CharacterShape

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CharacterShape

where CharacterShape: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CharacterShape> for ComponentAsset

fn from(c: CharacterShape) -> Self

Converts to this type from the input type.

impl RuntimeComponent for CharacterShape

impl Serialize for CharacterShape

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.