Struct LayerTransform 

pub struct LayerTransform {
    pub affine: Affine,
}

What a layer does at compositing, for painting a scene by hand. The transform applied to a layer (Primitive::Layer) at compositing time: an arbitrary Affine (translation, per-axis scale, rotation, or any composition of them) in screen pixels. The layer is first rendered flat into a texture, as with group opacity, then composited transformed — so a single pass transforms a whole subtree (rects, text, images) without touching any individual primitive’s shaders.

Fields

affine: Affine

The local (flat) → screen transform.

Implementations

impl LayerTransform

pub const fn new(affine: Affine) -> LayerTransform

Wraps any Affine.

pub fn rotation(angle: f32, pivot: Point) -> LayerTransform

A rotation of angle radians about pivot, in screen pixels.

pub fn scaled(self, factor: f32) -> LayerTransform

Conjugates the transform by a scale, so it follows Primitive::scaled: S ∘ M ∘ S⁻¹, which is what makes a DPI change scale the whole layer, its transform included.

pub fn scaled_xy(self, sx: f32, sy: f32) -> LayerTransform

Like LayerTransform::scaled, but per axis.

pub fn translated(self, dx: f32, dy: f32) -> LayerTransform

Conjugates by a translation, so it follows Primitive::translated.

Trait Implementations

impl Clone for LayerTransform

fn clone(&self) -> LayerTransform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LayerTransform

impl Debug for LayerTransform

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

Formats the value using the given formatter.

impl PartialEq for LayerTransform

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LayerTransform