mirror of
https://github.com/servo/servo.git
synced 2025-07-13 10:23:40 +01:00
3a38e815ec
DOMMatrix needs to convert a specified transform list into a matrix, so we could rewrite to_transform_3d_matrix by generics for both specified and computed transform lists. Besides, we have to update the test case because we use Transform3D<f64> to compute the matrix, instead of Transform3D<f32>, so the result will be the same as that in Gecko. Using 0.3 may cause floating point issue because (0.3f32 as f64) is not equal to 0.3 (i.e. floating point precision issue), so using 0.25 instead.
755 lines
28 KiB
Rust
755 lines
28 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
//! Generic types for CSS values that are related to transformations.
|
|
|
|
use app_units::Au;
|
|
use euclid::{Radians, Rect, Transform3D};
|
|
use num_traits::Zero;
|
|
use std::fmt;
|
|
use style_traits::ToCss;
|
|
use values::{computed, CSSFloat};
|
|
use values::computed::length::Length as ComputedLength;
|
|
use values::computed::length::LengthOrPercentage as ComputedLengthOrPercentage;
|
|
use values::specified::length::Length as SpecifiedLength;
|
|
use values::specified::length::LengthOrPercentage as SpecifiedLengthOrPercentage;
|
|
|
|
/// A generic 2D transformation matrix.
|
|
#[allow(missing_docs)]
|
|
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss)]
|
|
#[css(comma, function)]
|
|
pub struct Matrix<T, U = T> {
|
|
pub a: T,
|
|
pub b: T,
|
|
pub c: T,
|
|
pub d: T,
|
|
pub e: U,
|
|
pub f: U,
|
|
}
|
|
|
|
#[allow(missing_docs)]
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
|
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
|
|
pub struct Matrix3D<T, U = T, V = T> {
|
|
pub m11: T, pub m12: T, pub m13: T, pub m14: T,
|
|
pub m21: T, pub m22: T, pub m23: T, pub m24: T,
|
|
pub m31: T, pub m32: T, pub m33: T, pub m34: T,
|
|
pub m41: U, pub m42: U, pub m43: V, pub m44: T,
|
|
}
|
|
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
|
impl<T: Into<f64>> From<Matrix<T>> for Transform3D<f64> {
|
|
#[inline]
|
|
fn from(m: Matrix<T>) -> Self {
|
|
Transform3D::row_major(
|
|
m.a.into(), m.b.into(), 0.0, 0.0,
|
|
m.c.into(), m.d.into(), 0.0, 0.0,
|
|
0.0, 0.0, 1.0, 0.0,
|
|
m.e.into(), m.f.into(), 0.0, 1.0,
|
|
)
|
|
}
|
|
}
|
|
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
|
impl<T: Into<f64>> From<Matrix3D<T>> for Transform3D<f64> {
|
|
#[inline]
|
|
fn from(m: Matrix3D<T>) -> Self {
|
|
Transform3D::row_major(
|
|
m.m11.into(), m.m12.into(), m.m13.into(), m.m14.into(),
|
|
m.m21.into(), m.m22.into(), m.m23.into(), m.m24.into(),
|
|
m.m31.into(), m.m32.into(), m.m33.into(), m.m34.into(),
|
|
m.m41.into(), m.m42.into(), m.m43.into(), m.m44.into(),
|
|
)
|
|
}
|
|
}
|
|
|
|
/// A generic transform origin.
|
|
#[derive(Animate, Clone, ComputeSquaredDistance, Copy, Debug)]
|
|
#[derive(MallocSizeOf, PartialEq, ToAnimatedZero, ToComputedValue, ToCss)]
|
|
pub struct TransformOrigin<H, V, Depth> {
|
|
/// The horizontal origin.
|
|
pub horizontal: H,
|
|
/// The vertical origin.
|
|
pub vertical: V,
|
|
/// The depth.
|
|
pub depth: Depth,
|
|
}
|
|
|
|
/// A generic timing function.
|
|
///
|
|
/// <https://drafts.csswg.org/css-timing-1/#single-timing-function-production>
|
|
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
|
|
pub enum TimingFunction<Integer, Number> {
|
|
/// `linear | ease | ease-in | ease-out | ease-in-out`
|
|
Keyword(TimingKeyword),
|
|
/// `cubic-bezier(<number>, <number>, <number>, <number>)`
|
|
#[allow(missing_docs)]
|
|
CubicBezier {
|
|
x1: Number,
|
|
y1: Number,
|
|
x2: Number,
|
|
y2: Number,
|
|
},
|
|
/// `step-start | step-end | steps(<integer>, [ start | end ]?)`
|
|
Steps(Integer, StepPosition),
|
|
/// `frames(<integer>)`
|
|
Frames(Integer),
|
|
}
|
|
|
|
define_css_keyword_enum! { TimingKeyword:
|
|
"linear" => Linear,
|
|
"ease" => Ease,
|
|
"ease-in" => EaseIn,
|
|
"ease-out" => EaseOut,
|
|
"ease-in-out" => EaseInOut,
|
|
}
|
|
add_impls_for_keyword_enum!(TimingKeyword);
|
|
|
|
define_css_keyword_enum! { StepPosition:
|
|
"start" => Start,
|
|
"end" => End,
|
|
}
|
|
add_impls_for_keyword_enum!(StepPosition);
|
|
|
|
impl<H, V, D> TransformOrigin<H, V, D> {
|
|
/// Returns a new transform origin.
|
|
pub fn new(horizontal: H, vertical: V, depth: D) -> Self {
|
|
Self {
|
|
horizontal: horizontal,
|
|
vertical: vertical,
|
|
depth: depth,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<Integer, Number> TimingFunction<Integer, Number> {
|
|
/// `ease`
|
|
#[inline]
|
|
pub fn ease() -> Self {
|
|
TimingFunction::Keyword(TimingKeyword::Ease)
|
|
}
|
|
}
|
|
|
|
impl<Integer, Number> ToCss for TimingFunction<Integer, Number>
|
|
where
|
|
Integer: ToCss,
|
|
Number: ToCss,
|
|
{
|
|
fn to_css<W>(&self, dest: &mut W) -> fmt::Result
|
|
where
|
|
W: fmt::Write,
|
|
{
|
|
match *self {
|
|
TimingFunction::Keyword(keyword) => keyword.to_css(dest),
|
|
TimingFunction::CubicBezier {
|
|
ref x1,
|
|
ref y1,
|
|
ref x2,
|
|
ref y2,
|
|
} => {
|
|
dest.write_str("cubic-bezier(")?;
|
|
x1.to_css(dest)?;
|
|
dest.write_str(", ")?;
|
|
y1.to_css(dest)?;
|
|
dest.write_str(", ")?;
|
|
x2.to_css(dest)?;
|
|
dest.write_str(", ")?;
|
|
y2.to_css(dest)?;
|
|
dest.write_str(")")
|
|
},
|
|
TimingFunction::Steps(ref intervals, position) => {
|
|
dest.write_str("steps(")?;
|
|
intervals.to_css(dest)?;
|
|
if position != StepPosition::End {
|
|
dest.write_str(", ")?;
|
|
position.to_css(dest)?;
|
|
}
|
|
dest.write_str(")")
|
|
},
|
|
TimingFunction::Frames(ref frames) => {
|
|
dest.write_str("frames(")?;
|
|
frames.to_css(dest)?;
|
|
dest.write_str(")")
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TimingKeyword {
|
|
/// Returns the keyword as a quadruplet of Bezier point coordinates
|
|
/// `(x1, y1, x2, y2)`.
|
|
#[inline]
|
|
pub fn to_bezier(self) -> (CSSFloat, CSSFloat, CSSFloat, CSSFloat) {
|
|
match self {
|
|
TimingKeyword::Linear => (0., 0., 1., 1.),
|
|
TimingKeyword::Ease => (0.25, 0.1, 0.25, 1.),
|
|
TimingKeyword::EaseIn => (0.42, 0., 1., 1.),
|
|
TimingKeyword::EaseOut => (0., 0., 0.58, 1.),
|
|
TimingKeyword::EaseInOut => (0.42, 0., 0.58, 1.),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
|
|
/// A single operation in the list of a `transform` value
|
|
pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrNumber, LengthOrPercentage, LoPoNumber> {
|
|
/// Represents a 2D 2x3 matrix.
|
|
Matrix(Matrix<Number>),
|
|
/// Represents a 3D 4x4 matrix with percentage and length values.
|
|
/// For `moz-transform`.
|
|
PrefixedMatrix(Matrix<Number, LoPoNumber>),
|
|
/// Represents a 3D 4x4 matrix.
|
|
#[allow(missing_docs)]
|
|
Matrix3D(Matrix3D<Number>),
|
|
/// Represents a 3D 4x4 matrix with percentage and length values.
|
|
/// For `moz-transform`.
|
|
#[allow(missing_docs)]
|
|
PrefixedMatrix3D(Matrix3D<Number, LoPoNumber, LengthOrNumber>),
|
|
/// A 2D skew.
|
|
///
|
|
/// If the second angle is not provided it is assumed zero.
|
|
///
|
|
/// Syntax can be skew(angle) or skew(angle, angle)
|
|
Skew(Angle, Option<Angle>),
|
|
/// skewX(angle)
|
|
SkewX(Angle),
|
|
/// skewY(angle)
|
|
SkewY(Angle),
|
|
/// translate(x, y) or translate(x)
|
|
Translate(LengthOrPercentage, Option<LengthOrPercentage>),
|
|
/// translateX(x)
|
|
TranslateX(LengthOrPercentage),
|
|
/// translateY(y)
|
|
TranslateY(LengthOrPercentage),
|
|
/// translateZ(z)
|
|
TranslateZ(Length),
|
|
/// translate3d(x, y, z)
|
|
Translate3D(LengthOrPercentage, LengthOrPercentage, Length),
|
|
/// A 2D scaling factor.
|
|
///
|
|
/// `scale(2)` is parsed as `Scale(Number::new(2.0), None)` and is equivalent to
|
|
/// writing `scale(2, 2)` (`Scale(Number::new(2.0), Some(Number::new(2.0)))`).
|
|
///
|
|
/// Negative values are allowed and flip the element.
|
|
///
|
|
/// Syntax can be scale(factor) or scale(factor, factor)
|
|
Scale(Number, Option<Number>),
|
|
/// scaleX(factor)
|
|
ScaleX(Number),
|
|
/// scaleY(factor)
|
|
ScaleY(Number),
|
|
/// scaleZ(factor)
|
|
ScaleZ(Number),
|
|
/// scale3D(factorX, factorY, factorZ)
|
|
Scale3D(Number, Number, Number),
|
|
/// Describes a 2D Rotation.
|
|
///
|
|
/// In a 3D scene `rotate(angle)` is equivalent to `rotateZ(angle)`.
|
|
Rotate(Angle),
|
|
/// Rotation in 3D space around the x-axis.
|
|
RotateX(Angle),
|
|
/// Rotation in 3D space around the y-axis.
|
|
RotateY(Angle),
|
|
/// Rotation in 3D space around the z-axis.
|
|
RotateZ(Angle),
|
|
/// Rotation in 3D space.
|
|
///
|
|
/// Generalization of rotateX, rotateY and rotateZ.
|
|
Rotate3D(Number, Number, Number, Angle),
|
|
/// Specifies a perspective projection matrix.
|
|
///
|
|
/// Part of CSS Transform Module Level 2 and defined at
|
|
/// [§ 13.1. 3D Transform Function](https://drafts.csswg.org/css-transforms-2/#funcdef-perspective).
|
|
///
|
|
/// The value must be greater than or equal to zero.
|
|
Perspective(Length),
|
|
/// A intermediate type for interpolation of mismatched transform lists.
|
|
#[allow(missing_docs)]
|
|
InterpolateMatrix {
|
|
#[compute(ignore_bound)]
|
|
from_list: Transform<
|
|
TransformOperation<
|
|
Angle,
|
|
Number,
|
|
Length,
|
|
Integer,
|
|
LengthOrNumber,
|
|
LengthOrPercentage,
|
|
LoPoNumber,
|
|
>,
|
|
>,
|
|
#[compute(ignore_bound)]
|
|
to_list: Transform<
|
|
TransformOperation<
|
|
Angle,
|
|
Number,
|
|
Length,
|
|
Integer,
|
|
LengthOrNumber,
|
|
LengthOrPercentage,
|
|
LoPoNumber,
|
|
>,
|
|
>,
|
|
#[compute(clone)]
|
|
progress: computed::Percentage,
|
|
},
|
|
/// A intermediate type for accumulation of mismatched transform lists.
|
|
#[allow(missing_docs)]
|
|
AccumulateMatrix {
|
|
#[compute(ignore_bound)]
|
|
from_list: Transform<
|
|
TransformOperation<
|
|
Angle,
|
|
Number,
|
|
Length,
|
|
Integer,
|
|
LengthOrNumber,
|
|
LengthOrPercentage,
|
|
LoPoNumber,
|
|
>,
|
|
>,
|
|
#[compute(ignore_bound)]
|
|
to_list: Transform<
|
|
TransformOperation<
|
|
Angle,
|
|
Number,
|
|
Length,
|
|
Integer,
|
|
LengthOrNumber,
|
|
LengthOrPercentage,
|
|
LoPoNumber,
|
|
>,
|
|
>,
|
|
count: Integer,
|
|
},
|
|
}
|
|
|
|
#[derive(Animate, ToComputedValue)]
|
|
#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
|
|
/// A value of the `transform` property
|
|
pub struct Transform<T>(pub Vec<T>);
|
|
|
|
impl<Angle, Number, Length, Integer, LengthOrNumber, LengthOrPercentage, LoPoNumber>
|
|
TransformOperation<Angle, Number, Length, Integer, LengthOrNumber, LengthOrPercentage, LoPoNumber> {
|
|
/// Check if it is any translate function
|
|
pub fn is_translate(&self) -> bool {
|
|
use self::TransformOperation::*;
|
|
match *self {
|
|
Translate(..) | Translate3D(..) | TranslateX(..) | TranslateY(..) | TranslateZ(..) => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
/// Check if it is any scale function
|
|
pub fn is_scale(&self) -> bool {
|
|
use self::TransformOperation::*;
|
|
match *self {
|
|
Scale(..) | Scale3D(..) | ScaleX(..) | ScaleY(..) | ScaleZ(..) => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Convert a length type into the absolute lengths.
|
|
pub trait ToAbsoluteLength {
|
|
/// Returns the absolute length as pixel value.
|
|
fn to_pixel_length(&self, containing_len: Option<Au>) -> Result<CSSFloat, ()>;
|
|
}
|
|
|
|
impl ToAbsoluteLength for SpecifiedLength {
|
|
// This returns Err(()) if there is any relative length or percentage. We use this when
|
|
// parsing a transform list of DOMMatrix because we want to return a DOM Exception
|
|
// if there is relative length.
|
|
#[inline]
|
|
fn to_pixel_length(&self, _containing_len: Option<Au>) -> Result<CSSFloat, ()> {
|
|
match *self {
|
|
SpecifiedLength::NoCalc(len) => len.to_computed_pixel_length_without_context(),
|
|
SpecifiedLength::Calc(ref calc) => calc.to_computed_pixel_length_without_context(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ToAbsoluteLength for SpecifiedLengthOrPercentage {
|
|
// This returns Err(()) if there is any relative length or percentage. We use this when
|
|
// parsing a transform list of DOMMatrix because we want to return a DOM Exception
|
|
// if there is relative length.
|
|
#[inline]
|
|
fn to_pixel_length(&self, _containing_len: Option<Au>) -> Result<CSSFloat, ()> {
|
|
use self::SpecifiedLengthOrPercentage::*;
|
|
match *self {
|
|
Length(len) => len.to_computed_pixel_length_without_context(),
|
|
Calc(ref calc) => calc.to_computed_pixel_length_without_context(),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ToAbsoluteLength for ComputedLength {
|
|
#[inline]
|
|
fn to_pixel_length(&self, _containing_len: Option<Au>) -> Result<CSSFloat, ()> {
|
|
Ok(self.px())
|
|
}
|
|
}
|
|
|
|
impl ToAbsoluteLength for ComputedLengthOrPercentage {
|
|
#[inline]
|
|
fn to_pixel_length(&self, containing_len: Option<Au>) -> Result<CSSFloat, ()> {
|
|
let extract_pixel_length = |lop: &ComputedLengthOrPercentage| match *lop {
|
|
ComputedLengthOrPercentage::Length(px) => px.px(),
|
|
ComputedLengthOrPercentage::Percentage(_) => 0.,
|
|
ComputedLengthOrPercentage::Calc(calc) => calc.length().px(),
|
|
};
|
|
|
|
match containing_len {
|
|
Some(relative_len) => Ok(self.to_pixel_length(relative_len).px()),
|
|
// If we don't have reference box, we cannot resolve the used value,
|
|
// so only retrieve the length part. This will be used for computing
|
|
// distance without any layout info.
|
|
None => Ok(extract_pixel_length(self))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Support the conversion to a 3d matrix.
|
|
pub trait ToMatrix {
|
|
/// Check if it is a 3d transform function.
|
|
fn is_3d(&self) -> bool;
|
|
|
|
/// Return the equivalent 3d matrix.
|
|
fn to_3d_matrix(&self, reference_box: Option<&Rect<Au>>) -> Result<Transform3D<f64>, ()>;
|
|
}
|
|
|
|
impl<Angle, Number, Length, Integer, LoN, LoP, LoPoNumber> ToMatrix
|
|
for TransformOperation<Angle, Number, Length, Integer, LoN, LoP, LoPoNumber>
|
|
where
|
|
Angle: Copy + AsRef<computed::angle::Angle>,
|
|
Number: Copy + Into<f32> + Into<f64>,
|
|
Length: ToAbsoluteLength,
|
|
LoP: ToAbsoluteLength,
|
|
{
|
|
#[inline]
|
|
fn is_3d(&self) -> bool {
|
|
use self::TransformOperation::*;
|
|
match *self {
|
|
Translate3D(..) | TranslateZ(..) |
|
|
Rotate3D(..) | RotateX(..) | RotateY(..) | RotateZ(..) |
|
|
Scale3D(..) | ScaleZ(..) |
|
|
Perspective(..) | Matrix3D(..) | PrefixedMatrix3D(..) => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
/// If |reference_box| is None, we will drop the percent part from translate because
|
|
/// we cannot resolve it without the layout info, for computed TransformOperation.
|
|
/// However, for specified TransformOperation, we will return Err(()) if there is any relative
|
|
/// lengths because the only caller, DOMMatrix, doesn't accept relative lengths.
|
|
#[inline]
|
|
fn to_3d_matrix(&self, reference_box: Option<&Rect<Au>>) -> Result<Transform3D<f64>, ()> {
|
|
use self::TransformOperation::*;
|
|
use std::f64;
|
|
|
|
const TWO_PI: f64 = 2.0f64 * f64::consts::PI;
|
|
let reference_width = reference_box.map(|v| v.size.width);
|
|
let reference_height = reference_box.map(|v| v.size.height);
|
|
let matrix = match *self {
|
|
Rotate3D(ax, ay, az, theta) => {
|
|
let theta = TWO_PI - theta.as_ref().radians64();
|
|
let (ax, ay, az, theta) =
|
|
get_normalized_vector_and_angle(ax.into(), ay.into(), az.into(), theta);
|
|
Transform3D::create_rotation(ax as f64, ay as f64, az as f64, Radians::new(theta))
|
|
},
|
|
RotateX(theta) => {
|
|
let theta = Radians::new(TWO_PI - theta.as_ref().radians64());
|
|
Transform3D::create_rotation(1., 0., 0., theta)
|
|
},
|
|
RotateY(theta) => {
|
|
let theta = Radians::new(TWO_PI - theta.as_ref().radians64());
|
|
Transform3D::create_rotation(0., 1., 0., theta)
|
|
},
|
|
RotateZ(theta) | Rotate(theta) => {
|
|
let theta = Radians::new(TWO_PI - theta.as_ref().radians64());
|
|
Transform3D::create_rotation(0., 0., 1., theta)
|
|
},
|
|
Perspective(ref d) => {
|
|
let m = create_perspective_matrix(d.to_pixel_length(None)?);
|
|
m.cast().expect("Casting from f32 to f64 should be successful")
|
|
},
|
|
Scale3D(sx, sy, sz) => Transform3D::create_scale(sx.into(), sy.into(), sz.into()),
|
|
Scale(sx, sy) => Transform3D::create_scale(sx.into(), sy.unwrap_or(sx).into(), 1.),
|
|
ScaleX(s) => Transform3D::create_scale(s.into(), 1., 1.),
|
|
ScaleY(s) => Transform3D::create_scale(1., s.into(), 1.),
|
|
ScaleZ(s) => Transform3D::create_scale(1., 1., s.into()),
|
|
Translate3D(ref tx, ref ty, ref tz) => {
|
|
let tx = tx.to_pixel_length(reference_width)? as f64;
|
|
let ty = ty.to_pixel_length(reference_height)? as f64;
|
|
Transform3D::create_translation(tx, ty, tz.to_pixel_length(None)? as f64)
|
|
},
|
|
Translate(ref tx, Some(ref ty)) => {
|
|
let tx = tx.to_pixel_length(reference_width)? as f64;
|
|
let ty = ty.to_pixel_length(reference_height)? as f64;
|
|
Transform3D::create_translation(tx, ty, 0.)
|
|
},
|
|
TranslateX(ref t) | Translate(ref t, None) => {
|
|
let t = t.to_pixel_length(reference_width)? as f64;
|
|
Transform3D::create_translation(t, 0., 0.)
|
|
},
|
|
TranslateY(ref t) => {
|
|
let t = t.to_pixel_length(reference_height)? as f64;
|
|
Transform3D::create_translation(0., t, 0.)
|
|
},
|
|
TranslateZ(ref z) => {
|
|
Transform3D::create_translation(0., 0., z.to_pixel_length(None)? as f64)
|
|
},
|
|
Skew(theta_x, theta_y) => {
|
|
Transform3D::create_skew(
|
|
Radians::new(theta_x.as_ref().radians64()),
|
|
Radians::new(theta_y.map_or(0., |a| a.as_ref().radians64())),
|
|
)
|
|
},
|
|
SkewX(theta) => {
|
|
Transform3D::create_skew(
|
|
Radians::new(theta.as_ref().radians64()),
|
|
Radians::new(0.),
|
|
)
|
|
},
|
|
SkewY(theta) => {
|
|
Transform3D::create_skew(
|
|
Radians::new(0.),
|
|
Radians::new(theta.as_ref().radians64()),
|
|
)
|
|
},
|
|
Matrix3D(m) => m.into(),
|
|
Matrix(m) => m.into(),
|
|
PrefixedMatrix3D(_) | PrefixedMatrix(_) => {
|
|
unreachable!("-moz-transform` is not implemented in Servo yet, and DOMMatrix \
|
|
doesn't support this")
|
|
},
|
|
InterpolateMatrix { .. } | AccumulateMatrix { .. } => {
|
|
// TODO: Convert InterpolateMatrix/AccumulateMatrix into a valid Transform3D by
|
|
// the reference box and do interpolation on these two Transform3D matrices.
|
|
// Both Gecko and Servo don't support this for computing distance, and Servo
|
|
// doesn't support animations on InterpolateMatrix/AccumulateMatrix, so
|
|
// return an identity matrix.
|
|
// Note: DOMMatrix doesn't go into this arm.
|
|
Transform3D::identity()
|
|
},
|
|
};
|
|
Ok(matrix)
|
|
}
|
|
}
|
|
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
|
impl<Angle: ToCss + Copy, Number: ToCss + Copy, Length: ToCss,
|
|
Integer: ToCss + Copy, LengthOrNumber: ToCss, LengthOrPercentage: ToCss, LoPoNumber: ToCss>
|
|
ToCss for
|
|
TransformOperation<Angle, Number, Length, Integer, LengthOrNumber, LengthOrPercentage, LoPoNumber> {
|
|
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
|
|
match *self {
|
|
TransformOperation::Matrix(ref m) => m.to_css(dest),
|
|
TransformOperation::PrefixedMatrix(ref m) => m.to_css(dest),
|
|
TransformOperation::Matrix3D(Matrix3D {
|
|
m11, m12, m13, m14,
|
|
m21, m22, m23, m24,
|
|
m31, m32, m33, m34,
|
|
m41, m42, m43, m44,
|
|
}) => {
|
|
serialize_function!(dest, matrix3d(
|
|
m11, m12, m13, m14,
|
|
m21, m22, m23, m24,
|
|
m31, m32, m33, m34,
|
|
m41, m42, m43, m44,
|
|
))
|
|
}
|
|
TransformOperation::PrefixedMatrix3D(Matrix3D {
|
|
m11, m12, m13, m14,
|
|
m21, m22, m23, m24,
|
|
m31, m32, m33, m34,
|
|
ref m41, ref m42, ref m43, m44,
|
|
}) => {
|
|
serialize_function!(dest, matrix3d(
|
|
m11, m12, m13, m14,
|
|
m21, m22, m23, m24,
|
|
m31, m32, m33, m34,
|
|
m41, m42, m43, m44,
|
|
))
|
|
}
|
|
TransformOperation::Skew(ax, None) => {
|
|
serialize_function!(dest, skew(ax))
|
|
}
|
|
TransformOperation::Skew(ax, Some(ay)) => {
|
|
serialize_function!(dest, skew(ax, ay))
|
|
}
|
|
TransformOperation::SkewX(angle) => {
|
|
serialize_function!(dest, skewX(angle))
|
|
}
|
|
TransformOperation::SkewY(angle) => {
|
|
serialize_function!(dest, skewY(angle))
|
|
}
|
|
TransformOperation::Translate(ref tx, None) => {
|
|
serialize_function!(dest, translate(tx))
|
|
}
|
|
TransformOperation::Translate(ref tx, Some(ref ty)) => {
|
|
serialize_function!(dest, translate(tx, ty))
|
|
}
|
|
TransformOperation::TranslateX(ref tx) => {
|
|
serialize_function!(dest, translateX(tx))
|
|
}
|
|
TransformOperation::TranslateY(ref ty) => {
|
|
serialize_function!(dest, translateY(ty))
|
|
}
|
|
TransformOperation::TranslateZ(ref tz) => {
|
|
serialize_function!(dest, translateZ(tz))
|
|
}
|
|
TransformOperation::Translate3D(ref tx, ref ty, ref tz) => {
|
|
serialize_function!(dest, translate3d(tx, ty, tz))
|
|
}
|
|
TransformOperation::Scale(factor, None) => {
|
|
serialize_function!(dest, scale(factor))
|
|
}
|
|
TransformOperation::Scale(sx, Some(sy)) => {
|
|
serialize_function!(dest, scale(sx, sy))
|
|
}
|
|
TransformOperation::ScaleX(sx) => {
|
|
serialize_function!(dest, scaleX(sx))
|
|
}
|
|
TransformOperation::ScaleY(sy) => {
|
|
serialize_function!(dest, scaleY(sy))
|
|
}
|
|
TransformOperation::ScaleZ(sz) => {
|
|
serialize_function!(dest, scaleZ(sz))
|
|
}
|
|
TransformOperation::Scale3D(sx, sy, sz) => {
|
|
serialize_function!(dest, scale3d(sx, sy, sz))
|
|
}
|
|
TransformOperation::Rotate(theta) => {
|
|
serialize_function!(dest, rotate(theta))
|
|
}
|
|
TransformOperation::RotateX(theta) => {
|
|
serialize_function!(dest, rotateX(theta))
|
|
}
|
|
TransformOperation::RotateY(theta) => {
|
|
serialize_function!(dest, rotateY(theta))
|
|
}
|
|
TransformOperation::RotateZ(theta) => {
|
|
serialize_function!(dest, rotateZ(theta))
|
|
}
|
|
TransformOperation::Rotate3D(x, y, z, theta) => {
|
|
serialize_function!(dest, rotate3d(x, y, z, theta))
|
|
}
|
|
TransformOperation::Perspective(ref length) => {
|
|
serialize_function!(dest, perspective(length))
|
|
}
|
|
TransformOperation::InterpolateMatrix { ref from_list, ref to_list, progress } => {
|
|
serialize_function!(dest, interpolatematrix(from_list, to_list, progress))
|
|
}
|
|
TransformOperation::AccumulateMatrix { ref from_list, ref to_list, count } => {
|
|
serialize_function!(dest, accumulatematrix(from_list, to_list, count))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: ToCss> ToCss for Transform<T> {
|
|
fn to_css<W>(&self, dest: &mut W) -> fmt::Result
|
|
where
|
|
W: fmt::Write,
|
|
{
|
|
if self.0.is_empty() {
|
|
return dest.write_str("none");
|
|
}
|
|
|
|
let mut first = true;
|
|
for operation in &self.0 {
|
|
if !first {
|
|
dest.write_str(" ")?;
|
|
}
|
|
first = false;
|
|
operation.to_css(dest)?
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<T> Transform<T> {
|
|
/// `none`
|
|
pub fn none() -> Self {
|
|
Transform(vec![])
|
|
}
|
|
}
|
|
|
|
impl<T: ToMatrix> Transform<T> {
|
|
/// Return the equivalent 3d matrix of this transform list.
|
|
/// We return a pair: the first one is the transform matrix, and the second one
|
|
/// indicates if there is any 3d transform function in this transform list.
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
|
pub fn to_transform_3d_matrix(
|
|
&self,
|
|
reference_box: Option<&Rect<Au>>
|
|
) -> Result<(Transform3D<CSSFloat>, bool), ()> {
|
|
let cast_3d_transform = |m: Transform3D<f64>| -> Transform3D<CSSFloat> {
|
|
use std::{f32, f64};
|
|
let cast = |v: f64| { v.min(f32::MAX as f64).max(f32::MIN as f64) as f32 };
|
|
Transform3D::row_major(
|
|
cast(m.m11), cast(m.m12), cast(m.m13), cast(m.m14),
|
|
cast(m.m21), cast(m.m22), cast(m.m23), cast(m.m24),
|
|
cast(m.m31), cast(m.m32), cast(m.m33), cast(m.m34),
|
|
cast(m.m41), cast(m.m42), cast(m.m43), cast(m.m44),
|
|
)
|
|
};
|
|
|
|
// We intentionally use Transform3D<f64> during computation to avoid error propagation
|
|
// because using f32 to compute triangle functions (e.g. in create_rotation()) is not
|
|
// accurate enough. In Gecko, we also use "double" to compute the triangle functions.
|
|
// Therefore, let's use Transform3D<f64> during matrix computation and cast it into f32
|
|
// in the end.
|
|
let mut transform = Transform3D::<f64>::identity();
|
|
let mut contain_3d = false;
|
|
|
|
for operation in &self.0 {
|
|
let matrix = operation.to_3d_matrix(reference_box)?;
|
|
contain_3d |= operation.is_3d();
|
|
transform = transform.pre_mul(&matrix);
|
|
}
|
|
|
|
Ok((cast_3d_transform(transform), contain_3d))
|
|
}
|
|
}
|
|
|
|
/// Return the transform matrix from a perspective length.
|
|
#[inline]
|
|
pub fn create_perspective_matrix(d: CSSFloat) -> Transform3D<CSSFloat> {
|
|
// TODO(gw): The transforms spec says that perspective length must
|
|
// be positive. However, there is some confusion between the spec
|
|
// and browser implementations as to handling the case of 0 for the
|
|
// perspective value. Until the spec bug is resolved, at least ensure
|
|
// that a provided perspective value of <= 0.0 doesn't cause panics
|
|
// and behaves as it does in other browsers.
|
|
// See https://lists.w3.org/Archives/Public/www-style/2016Jan/0020.html for more details.
|
|
if d <= 0.0 {
|
|
Transform3D::identity()
|
|
} else {
|
|
Transform3D::create_perspective(d)
|
|
}
|
|
}
|
|
|
|
/// Return the normalized direction vector and its angle for Rotate3D.
|
|
pub fn get_normalized_vector_and_angle<T: Zero>(
|
|
x: CSSFloat,
|
|
y: CSSFloat,
|
|
z: CSSFloat,
|
|
angle: T,
|
|
) -> (CSSFloat, CSSFloat, CSSFloat, T) {
|
|
use euclid::approxeq::ApproxEq;
|
|
use values::computed::transform::DirectionVector;
|
|
let vector = DirectionVector::new(x, y, z);
|
|
if vector.square_length().approx_eq(&f32::zero()) {
|
|
// https://www.w3.org/TR/css-transforms-1/#funcdef-rotate3d
|
|
// A direction vector that cannot be normalized, such as [0, 0, 0], will cause the
|
|
// rotation to not be applied, so we use identity matrix (i.e. rotate3d(0, 0, 1, 0)).
|
|
(0., 0., 1., T::zero())
|
|
} else {
|
|
let vector = vector.normalize();
|
|
(vector.x, vector.y, vector.z, angle)
|
|
}
|
|
}
|