Struct Transformed 

pub struct Transformed<T, G> {
    pub inner: T,
    pub transform: G,
}

An item paired with an external transform represented by G.

inner retains its own representation while transform controls the extracted geometry. Composition is explicit about order:

• compose_outer: transform = outer * transform;
• compose_inner: transform = transform * inner.

Applying an H through ApplyTransform is outer composition and is only available when H embeds into the existing storage type (G: From<H>). Operations never widen the wrapper automatically. Widen explicitly with Into::into when a more general storage type is required.

use ranim_core::{glam::DVec3, prelude::*};

let mut item = ().transformed(Similarity::IDENTITY);
// `Diag` does not embed into `Similarity`; choose `DAffine3` storage first.
item.scale(DVec3::new(2.0, 1.0, 1.0));

Extraction and Aabb calculation convert G to [DAffine3] only at the geometry boundary. Projective transforms remain outside the model-transform system.

Fields

inner: T

The item expressed in its own coordinates.

transform: G

The external transform applied to inner.

Implementations

impl<T, G> Transformed<T, G>

pub fn new(inner: T, transform: G) -> Transformed<T, G>

Pair inner with transform without converting either value.

pub fn map_inner<U, F>(self, f: F) -> Transformed<U, G>

where F: FnOnce(T) -> U,

Map the wrapped item to a new type, keeping transform unchanged.

pub fn map_transform<H, F>(self, f: F) -> Transformed<T, H>

where F: FnOnce(G) -> H,

Map the transform storage to a new type while keeping inner unchanged.

This is the general form of converting between transform groups — for example widening a placement or checked-narrowing an affine storage back to a subgroup. Lossless upward conversions need no closure at all: Transformed implements From<Transformed<T, X>> for Transformed<T, Y> whenever X embeds into Y, so prefer plain .into() there.

pub fn compose_outer<H>(&mut self, outer: H) -> &mut Transformed<T, G>

where G: TransformGroup + From<H>,

Compose outer on the left: transform = outer * transform.

pub fn compose_inner<H>(&mut self, inner: H) -> &mut Transformed<T, G>

where G: TransformGroup + From<H>,

Compose inner on the right: transform = transform * inner.

pub fn bake(self) -> T

where T: ApplyTransform<G>,

Bake the stored transform into inner and remove the wrapper.

This method exists only when T directly supports the wrapper’s exact transform representation G.

Trait Implementations

impl<T, G> Aabb for Transformed<T, G>

where T: Aabb, G: Clone + Into<DAffine3>,

fn aabb(&self) -> [DVec3; 2]

Get the Axis-aligned bounding box represent in [<min>, <max>].

fn aabb_size(&self) -> DVec3

Get the size of the Aabb.

fn aabb_center(&self) -> DVec3

Get the center of the Aabb.

impl<T, G> Alignable for Transformed<T, G>

where T: Alignable, G: Clone,

fn is_aligned(&self, other: &Transformed<T, G>) -> bool

Checking if two items are aligned

fn align_with(&mut self, other: &mut Transformed<T, G>)

Aligning two items

impl<T, G, H> ApplyTransform<H> for Transformed<T, G>

where G: TransformGroup + From<H>,

fn apply(&mut self, transform: H) -> &mut Transformed<T, G>

Bake transform (expressed in world coordinates) into the item’s data, in place.

impl<T, G> Clone for Transformed<T, G>

where T: Clone, G: Clone,

fn clone(&self) -> Transformed<T, G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, G> Debug for Transformed<T, G>

where T: Debug, G: Debug,

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

Formats the value using the given formatter.

impl<T, G> Empty for Transformed<T, G>

where T: Empty, G: TransformGroup,

fn empty() -> Transformed<T, G>

Create an empty placeholder of a wrapped item.

The inner item contributes T::empty() while the pose is G::identity(): an empty placeholder carries no geometry, so there is no meaningful placement to preserve — identity keeps it neutral for composition until real content is placed on it.

impl<T, G> Extract for Transformed<T, G>

where T: Extract<Target = CoreItem>, G: Clone + Into<DAffine3>,

type Target = CoreItem

Extraction target.

fn extract_into(&self, buf: &mut Vec<<Transformed<T, G> as Extract>::Target>)

Append extracted values to buf.

fn extract(&self) -> Vec<Self::Target>

Extract into a newly allocated vector.

impl<T, G> FillColor for Transformed<T, G>

where T: FillColor,

fn fill_color(&self) -> AlphaColor<Srgb>

Getting fill color of an item

fn set_fill_color(&mut self, color: AlphaColor<Srgb>) -> &mut Transformed<T, G>

Setting fill color(rgba) of an item

fn set_fill_opacity(&mut self, opacity: f32) -> &mut Transformed<T, G>

Setting fill opacity of an item

impl<I, G> From<Node<I, G>> for Transformed<Node<I, G>, G>

where G: TransformGroup,

A bare Node places with the identity pose, so plain and wrapped nodes mix freely in the same vec![...] of children.

fn from(inner: Node<I, G>) -> Transformed<Node<I, G>, G>

Converts to this type from the input type.

impl<T> From<Transformed<T, Diag>> for Transformed<T, DAffine3>

fn from(value: Transformed<T, Diag>) -> Transformed<T, DAffine3>

Converts to this type from the input type.

impl<T> From<Transformed<T, Rigid>> for Transformed<T, Similarity>

fn from(value: Transformed<T, Rigid>) -> Transformed<T, Similarity>

Converts to this type from the input type.

impl<T> From<Transformed<T, Rigid>> for Transformed<T, DAffine3>

fn from(value: Transformed<T, Rigid>) -> Transformed<T, DAffine3>

Converts to this type from the input type.

impl<T> From<Transformed<T, Similarity>> for Transformed<T, DAffine3>

fn from(value: Transformed<T, Similarity>) -> Transformed<T, DAffine3>

Converts to this type from the input type.

impl<T> From<Transformed<T, Translation>> for Transformed<T, Rigid>

fn from(value: Transformed<T, Translation>) -> Transformed<T, Rigid>

Converts to this type from the input type.

impl<T> From<Transformed<T, Translation>> for Transformed<T, Similarity>

fn from(value: Transformed<T, Translation>) -> Transformed<T, Similarity>

Converts to this type from the input type.

impl<T> From<Transformed<T, Translation>> for Transformed<T, DAffine3>

fn from(value: Transformed<T, Translation>) -> Transformed<T, DAffine3>

Converts to this type from the input type.

impl<T, G> Interpolatable for Transformed<T, G>

where T: Interpolatable, G: Interpolatable,

fn lerp(&self, target: &Transformed<T, G>, t: f64) -> Transformed<T, G>

Lerping between values

impl<T, G> Locate<Transformed<T, G>> for Centroid

where Centroid: Locate<T>, G: Clone + Into<DAffine3>,

fn locate(&self, target: &Transformed<T, G>) -> DVec3

Locate self on the target

impl<T, G> Locate<Transformed<T, G>> for Origin

where Origin: Locate<T>, G: Clone + Into<DAffine3>,

fn locate(&self, target: &Transformed<T, G>) -> DVec3

Locate self on the target

impl<T, G> Locate<Transformed<T, G>> for Focus

where Focus: Locate<T>, G: Clone + Into<DAffine3>,

fn locate(&self, target: &Transformed<T, G>) -> DVec3

Locate self on the target

impl<T, G> Opacity for Transformed<T, G>

where T: Opacity,

fn set_opacity(&mut self, opacity: f32) -> &mut Transformed<T, G>

Setting opacity of an item

impl<T, G> Partial for Transformed<T, G>

where T: Partial, G: Clone,

fn get_partial(&self, range: Range<f64>) -> Transformed<T, G>

Take a partial slice of the wrapped item, keeping the pose.

The range is forwarded to inner, so the partial geometry is taken in the item’s own coordinates, while the stored transform G is cloned unchanged. The wrapper therefore keeps its placement while the visible geometry grows from the slice, which is what create-style animations expect.

fn get_partial_closed(&self, range: Range<f64>) -> Transformed<T, G>

Take a closed partial slice of the wrapped item, keeping the pose.

Like get_partial, but the inner slice is closed so partially shown curves have caps at both ends; the wrapper’s transform is preserved.

impl<T, G> PartialEq for Transformed<T, G>

where T: PartialEq, G: PartialEq,

fn eq(&self, other: &Transformed<T, G>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<I, G> PlacedLeaves<I, G> for Transformed<Node<I, G>, G>

where G: Clone + Into<DAffine3>,

fn leaves(&self) -> Leaves<'_, I, G>

Iterate the placed tree’s leaf payloads with accumulated world affines (see Node::leaves).

fn leaves_mut(&mut self) -> LeavesMut<'_, I, G>

Mutable variant (no transforms are composed).

impl<T, G> StrokeColor for Transformed<T, G>

where T: StrokeColor,

fn stroke_color(&self) -> AlphaColor<Srgb>

Getting stroke color of an item

fn set_stroke_color( &mut self, color: AlphaColor<Srgb>, ) -> &mut Transformed<T, G>

Setting stroke color(rgba) of an item

fn set_stroke_opacity(&mut self, opacity: f32) -> &mut Transformed<T, G>

Setting stroke opacity of an item

impl<T, G> StrokeWidth for Transformed<T, G>

where T: StrokeWidth,

fn stroke_width(&self) -> f32

Get the stroke width

fn apply_stroke_func( &mut self, f: impl for<'a> Fn(&'a mut [Width]), ) -> &mut Transformed<T, G>

Applying stroke width function to an item

fn set_stroke_width(&mut self, width: f32) -> &mut Self

Setting stroke width of an item

impl<T, G> StructuralPartialEq for Transformed<T, G>

where T: PartialEq, G: PartialEq,