Struct TransformDelta 

#[non_exhaustive]
pub struct TransformDelta {
    pub pivot: Point,
    pub basis: f32,
    pub scale: Vec2,
    pub rotation: f32,
    pub translation: Vec2,
}

What one in-flight gesture asks of the selection, stated once in scene coordinates.

The preview paints it, the commit applies it, the scene’s geometry constraint rewrites it and the announcement describes it — so those four can never disagree.

The affine it denotes is, innermost first: move the pivot to the origin, rotate into the frame’s basis, scale, rotate back out, rotate by rotation, move the pivot back, translate. The scale is therefore taken along the frame’s own axes, which is what makes a rotated single-item frame resize exactly rather than shear.

#[non_exhaustive]: the crate hands this to consumer code — a ProposedChange reads it and TransformConfig::on_end records it — and the affine it denotes may grow a term. Build one with new, IDENTITY or between; the fields stay public and assignable.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

pivot: Point

Scene-space point every scale and rotation is taken about.

basis: f32

The frame’s angle, in radians — the basis the scale is expressed in.

scale: Vec2

Multiplier along the frame’s axes. Never negative: a resize stops at the controller’s min_size rather than mirroring, because a negative-extent Rect is silently un-hit-testable and un-indexable.

rotation: f32

Additive rotation, in radians.

translation: Vec2

Scene-space translation, applied last.

Implementations

impl TransformDelta

pub const IDENTITY: Self

The delta that changes nothing.

pub fn new( pivot: Point, basis: f32, scale: Vec2, rotation: f32, translation: Vec2, ) -> Self

A delta stated field by field — the constructor #[non_exhaustive] takes the place of a struct literal for.

The one an app reaches for to apply a programmatic transform through Scene::apply_transform_delta without driving a gesture. See the type’s own documentation for the order the five terms compose in.

pub fn is_identity(&self) -> bool

Whether applying this delta would leave every item where it is.

pub fn to_scene_transform(&self) -> Transform2D

The scene-space affine this delta denotes.

pub fn between( start: &TransformFrame, end: &TransformFrame, pivot: Point, ) -> Self

The delta that takes start to end about pivot.

The inverse of frame_after, and the reason a geometry constraint can hand back an adjusted frame and have the applied delta follow it exactly.

pub fn frame_after(&self, start: &TransformFrame) -> TransformFrame

The frame start becomes under this delta.

Trait Implementations

impl Clone for TransformDelta

fn clone(&self) -> TransformDelta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TransformDelta

impl Debug for TransformDelta

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

Formats the value using the given formatter.

impl PartialEq for TransformDelta

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TransformDelta