style: Implement transform: perspective(none)

Differential Revision: https://phabricator.services.mozilla.com/D123350
This commit is contained in:
Emilio Cobos Álvarez 2023-05-22 15:05:17 +02:00 committed by Oriol Brufau
parent ce45f68d9c
commit fa840e1666
4 changed files with 72 additions and 19 deletions

View file

@ -1105,8 +1105,8 @@ impl Animate for ComputedTransformOperation {
// interpolated as defined in section Interpolation of
// Matrices afterwards.
//
let from = create_perspective_matrix(fd.px());
let to = create_perspective_matrix(td.px());
let from = create_perspective_matrix(fd.infinity_or(|l| l.px()));
let to = create_perspective_matrix(td.infinity_or(|l| l.px()));
let interpolated = Matrix3D::from(from).animate(&Matrix3D::from(to), procedure)?;
@ -1115,15 +1115,17 @@ impl Animate for ComputedTransformOperation {
// Clamp results outside of the -1 to 0 range so that we get perspective
// function values between 1 and infinity.
let used_value = if perspective_z >= 0. {
std::f32::INFINITY
} else if perspective_z <= -1. {
1.
transform::PerspectiveFunction::None
} else {
-1. / perspective_z
transform::PerspectiveFunction::Length(CSSPixelLength::new(
if perspective_z <= -1. {
1.
} else {
-1. / perspective_z
}
))
};
Ok(TransformOperation::Perspective(CSSPixelLength::new(
used_value,
)))
Ok(TransformOperation::Perspective(used_value))
},
_ if self.is_translate() && other.is_translate() => self
.to_translate_3d()
@ -1202,14 +1204,18 @@ impl ComputeSquaredDistance for ComputedTransformOperation {
(
&TransformOperation::Perspective(ref fd),
&TransformOperation::Perspective(ref td),
) => fd.compute_squared_distance(td),
) => {
fd.infinity_or(|l| l.px())
.compute_squared_distance(&td.infinity_or(|l| l.px()))
},
(&TransformOperation::Perspective(ref p), &TransformOperation::Matrix3D(ref m)) |
(&TransformOperation::Matrix3D(ref m), &TransformOperation::Perspective(ref p)) => {
// FIXME(emilio): Is this right? Why interpolating this with
// Perspective but not with anything else?
let mut p_matrix = Matrix3D::identity();
if p.px() >= 0. {
p_matrix.m34 = -1. / p.px().max(1.);
let p = p.infinity_or(|p| p.px());
if p >= 0. {
p_matrix.m34 = -1. / p.max(1.);
}
p_matrix.compute_squared_distance(&m)
},

View file

@ -24,6 +24,9 @@ pub type Transform = generic::GenericTransform<TransformOperation>;
pub type TransformOrigin =
generic::GenericTransformOrigin<LengthPercentage, LengthPercentage, Length>;
/// The computed value of the `perspective()` transform function.
pub type PerspectiveFunction = generic::PerspectiveFunction<Length>;
/// A vector to represent the direction vector (rotate axis) for Rotate3D.
pub type DirectionVector = Vector3D<CSSFloat>;
@ -517,7 +520,7 @@ impl ToAnimatedZero for TransformOperation {
Ok(generic::TransformOperation::Rotate(Angle::zero()))
},
generic::TransformOperation::Perspective(_) => Ok(
generic::TransformOperation::Perspective(Length::new(std::f32::INFINITY))
generic::TransformOperation::Perspective(generic::PerspectiveFunction::None)
),
generic::TransformOperation::AccumulateMatrix { .. } |
generic::TransformOperation::InterpolateMatrix { .. } => {

View file

@ -141,6 +141,41 @@ fn is_same<N: PartialEq>(x: &N, y: &N) -> bool {
x == y
}
/// A value for the `perspective()` transform function, which is either a
/// non-negative `<length>` or `none`.
#[derive(
Clone,
Debug,
Deserialize,
MallocSizeOf,
PartialEq,
Serialize,
SpecifiedValueInfo,
ToComputedValue,
ToCss,
ToResolvedValue,
ToShmem,
)]
#[repr(C, u8)]
pub enum GenericPerspectiveFunction<L> {
/// `none`
None,
/// A `<length>`.
Length(L),
}
impl<L> GenericPerspectiveFunction<L> {
/// Returns `f32::INFINITY` or the result of a function on the length value.
pub fn infinity_or(&self, f: impl FnOnce(&L) -> f32) -> f32 {
match *self {
Self::None => std::f32::INFINITY,
Self::Length(ref l) => f(l),
}
}
}
pub use self::GenericPerspectiveFunction as PerspectiveFunction;
#[derive(
Clone,
Debug,
@ -240,7 +275,7 @@ where
///
/// The value must be greater than or equal to zero.
#[css(function)]
Perspective(Length),
Perspective(GenericPerspectiveFunction<Length>),
/// A intermediate type for interpolation of mismatched transform lists.
#[allow(missing_docs)]
#[css(comma, function = "interpolatematrix")]
@ -469,9 +504,12 @@ where
let theta = euclid::Angle::radians(theta.radians64());
Transform3D::rotation(0., 0., 1., theta)
},
Perspective(ref d) => {
let m = create_perspective_matrix(d.to_pixel_length(None)?);
m.cast()
Perspective(ref p) => {
let px = match p {
PerspectiveFunction::None => std::f32::INFINITY,
PerspectiveFunction::Length(ref p) => p.to_pixel_length(None)?,
};
create_perspective_matrix(px).cast()
},
Scale3D(sx, sy, sz) => Transform3D::scale(sx.into(), sy.into(), sz.into()),
Scale(sx, sy) => Transform3D::scale(sx.into(), sy.into(), 1.),

View file

@ -238,8 +238,14 @@ impl Transform {
Ok(generic::TransformOperation::SkewY(theta))
},
"perspective" => {
let d = specified::Length::parse_non_negative(context, input)?;
Ok(generic::TransformOperation::Perspective(d))
let p = match input.try_parse(|input| specified::Length::parse_non_negative(context, input)) {
Ok(p) => generic::PerspectiveFunction::Length(p),
Err(..) => {
input.expect_ident_matching("none")?;
generic::PerspectiveFunction::None
}
};
Ok(generic::TransformOperation::Perspective(p))
},
_ => Err(()),
};