mirror of
https://github.com/servo/servo.git
synced 2025-08-07 14:35:33 +01:00
Auto merge of #18234 - BorisChiou:stylo/transform/distance_mismatch, r=birtles,nox
stylo: Bug 1390039 - Implement compute_distance for mismatched transform lists. Implement ComputeSquaredDistance for mismatched transform lists. In order to do this, we have to convert a transform list into a 3d matrix, so I move the code from layout module into style module for reusing it. --- - [X] `./mach build -d` does not report any errors - [X] `./mach test-tidy` does not report any errors - [X] These changes fix [Bug 1390039](https://bugzilla.mozilla.org/show_bug.cgi?id=1390039). - [X] These changes do not require tests because this is a Gecko feature and I add many tests in Gecko already. <!-- Reviewable:start --> --- This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/18234) <!-- Reviewable:end -->
This commit is contained in:
bors-servo
GitHub
commit
3fa5d83ab7
5 changed files with 191 additions and 151 deletions
|
|
@ -8,7 +8,6 @@
|
|||
|
||||
use app_units::Au;
|
||||
use cssparser::Parser;
|
||||
use euclid::Point3D;
|
||||
#[cfg(feature = "gecko")] use gecko_bindings::bindings::RawServoAnimationValueMap;
|
||||
#[cfg(feature = "gecko")] use gecko_bindings::structs::RawGeckoGfxMatrix4x4;
|
||||
#[cfg(feature = "gecko")] use gecko_bindings::structs::nsCSSPropertyID;
|
||||
|
|
@ -54,6 +53,7 @@ use values::computed::{PositiveIntegerOrAuto, ToComputedValue};
|
|||
#[cfg(feature = "gecko")] use values::computed::MozLength;
|
||||
use values::computed::length::{NonNegativeLengthOrAuto, NonNegativeLengthOrNormal};
|
||||
use values::computed::length::NonNegativeLengthOrPercentage;
|
||||
use values::computed::transform::DirectionVector;
|
||||
use values::distance::{ComputeSquaredDistance, SquaredDistance};
|
||||
use values::generics::NonNegative;
|
||||
use values::generics::effects::Filter;
|
||||
|
|
@ -959,7 +959,7 @@ impl ToAnimatedZero for TransformOperation {
|
|||
Ok(TransformOperation::Scale(1.0, 1.0, 1.0))
|
||||
},
|
||||
TransformOperation::Rotate(x, y, z, a) => {
|
||||
let (x, y, z, _) = get_normalized_vector_and_angle(x, y, z, a);
|
||||
let (x, y, z, _) = TransformList::get_normalized_vector_and_angle(x, y, z, a);
|
||||
Ok(TransformOperation::Rotate(x, y, z, Angle::zero()))
|
||||
},
|
||||
TransformOperation::Perspective(..) |
|
||||
|
|
@ -1036,8 +1036,10 @@ impl Animate for TransformOperation {
|
|||
&TransformOperation::Rotate(fx, fy, fz, fa),
|
||||
&TransformOperation::Rotate(tx, ty, tz, ta),
|
||||
) => {
|
||||
let (fx, fy, fz, fa) = get_normalized_vector_and_angle(fx, fy, fz, fa);
|
||||
let (tx, ty, tz, ta) = get_normalized_vector_and_angle(tx, ty, tz, ta);
|
||||
let (fx, fy, fz, fa) =
|
||||
TransformList::get_normalized_vector_and_angle(fx, fy, fz, fa);
|
||||
let (tx, ty, tz, ta) =
|
||||
TransformList::get_normalized_vector_and_angle(tx, ty, tz, ta);
|
||||
if (fx, fy, fz) == (tx, ty, tz) {
|
||||
let ia = fa.animate(&ta, procedure)?;
|
||||
Ok(TransformOperation::Rotate(fx, fy, fz, ia))
|
||||
|
|
@ -1450,17 +1452,12 @@ pub struct MatrixDecomposed3D {
|
|||
pub quaternion: Quaternion,
|
||||
}
|
||||
|
||||
/// A wrapper of Point3D to represent the direction vector (rotate axis) for Rotate3D.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
|
||||
pub struct DirectionVector(Point3D<f64>);
|
||||
|
||||
impl Quaternion {
|
||||
/// Return a quaternion from a unit direction vector and angle (unit: radian).
|
||||
#[inline]
|
||||
fn from_direction_and_angle(vector: &DirectionVector, angle: f64) -> Self {
|
||||
debug_assert!((vector.length() - 1.).abs() < 0.0001f64,
|
||||
"Only accept an unit direction vector to create a quaternion");
|
||||
debug_assert!((vector.length() - 1.).abs() < 0.0001,
|
||||
"Only accept an unit direction vector to create a quaternion");
|
||||
// Reference:
|
||||
// https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
|
||||
//
|
||||
|
|
@ -1470,9 +1467,9 @@ impl Quaternion {
|
|||
// q = cos(theta/2) + (xi + yj + zk)(sin(theta/2))
|
||||
// = cos(theta/2) +
|
||||
// x*sin(theta/2)i + y*sin(theta/2)j + z*sin(theta/2)k
|
||||
Quaternion(vector.0.x * (angle / 2.).sin(),
|
||||
vector.0.y * (angle / 2.).sin(),
|
||||
vector.0.z * (angle / 2.).sin(),
|
||||
Quaternion(vector.x as f64 * (angle / 2.).sin(),
|
||||
vector.y as f64 * (angle / 2.).sin(),
|
||||
vector.z as f64 * (angle / 2.).sin(),
|
||||
(angle / 2.).cos())
|
||||
}
|
||||
|
||||
|
|
@ -1494,47 +1491,6 @@ impl ComputeSquaredDistance for Quaternion {
|
|||
}
|
||||
}
|
||||
|
||||
impl DirectionVector {
|
||||
/// Create a DirectionVector.
|
||||
#[inline]
|
||||
fn new(x: f32, y: f32, z: f32) -> Self {
|
||||
DirectionVector(Point3D::new(x as f64, y as f64, z as f64))
|
||||
}
|
||||
|
||||
/// Return the normalized direction vector.
|
||||
#[inline]
|
||||
fn normalize(&mut self) -> bool {
|
||||
let len = self.length();
|
||||
if len > 0. {
|
||||
self.0.x = self.0.x / len;
|
||||
self.0.y = self.0.y / len;
|
||||
self.0.z = self.0.z / len;
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the length of this vector.
|
||||
#[inline]
|
||||
fn length(&self) -> f64 {
|
||||
self.0.to_array().iter().fold(0f64, |sum, v| sum + v * v).sqrt()
|
||||
}
|
||||
}
|
||||
|
||||
/// Return the normalized direction vector and its angle.
|
||||
// A direction vector that cannot be normalized, such as [0,0,0], will cause the
|
||||
// rotation to not be applied. i.e. Use an identity matrix or rotate3d(0, 0, 1, 0).
|
||||
fn get_normalized_vector_and_angle(x: f32, y: f32, z: f32, angle: Angle)
|
||||
-> (f32, f32, f32, Angle) {
|
||||
let mut vector = DirectionVector::new(x, y, z);
|
||||
if vector.normalize() {
|
||||
(vector.0.x as f32, vector.0.y as f32, vector.0.z as f32, angle)
|
||||
} else {
|
||||
(0., 0., 1., Angle::zero())
|
||||
}
|
||||
}
|
||||
|
||||
/// Decompose a 3D matrix.
|
||||
/// https://drafts.csswg.org/css-transforms/#decomposing-a-3d-matrix
|
||||
fn decompose_3d_matrix(mut matrix: ComputedMatrix) -> Result<MatrixDecomposed3D, ()> {
|
||||
|
|
@ -2201,8 +2157,10 @@ impl ComputeSquaredDistance for TransformOperation {
|
|||
&TransformOperation::Rotate(fx, fy, fz, fa),
|
||||
&TransformOperation::Rotate(tx, ty, tz, ta),
|
||||
) => {
|
||||
let (fx, fy, fz, angle1) = get_normalized_vector_and_angle(fx, fy, fz, fa);
|
||||
let (tx, ty, tz, angle2) = get_normalized_vector_and_angle(tx, ty, tz, ta);
|
||||
let (fx, fy, fz, angle1) =
|
||||
TransformList::get_normalized_vector_and_angle(fx, fy, fz, fa);
|
||||
let (tx, ty, tz, angle2) =
|
||||
TransformList::get_normalized_vector_and_angle(tx, ty, tz, ta);
|
||||
if (fx, fy, fz) == (tx, ty, tz) {
|
||||
angle1.compute_squared_distance(&angle2)
|
||||
} else {
|
||||
|
|
@ -2249,10 +2207,10 @@ impl ComputeSquaredDistance for TransformOperation {
|
|||
impl ComputeSquaredDistance for TransformList {
|
||||
#[inline]
|
||||
fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
|
||||
let this = self.0.as_ref().map_or(&[][..], |l| l);
|
||||
let other = other.0.as_ref().map_or(&[][..], |l| l);
|
||||
let list1 = self.0.as_ref().map_or(&[][..], |l| l);
|
||||
let list2 = other.0.as_ref().map_or(&[][..], |l| l);
|
||||
|
||||
this.iter().zip_longest(other).map(|it| {
|
||||
let squared_dist: Result<SquaredDistance, _> = list1.iter().zip_longest(list2).map(|it| {
|
||||
match it {
|
||||
EitherOrBoth::Both(this, other) => {
|
||||
this.compute_squared_distance(other)
|
||||
|
|
@ -2261,7 +2219,16 @@ impl ComputeSquaredDistance for TransformList {
|
|||
list.to_animated_zero()?.compute_squared_distance(list)
|
||||
},
|
||||
}
|
||||
}).sum()
|
||||
}).sum();
|
||||
|
||||
// Roll back to matrix interpolation if there is any Err(()) in the transform lists, such
|
||||
// as mismatched transform functions.
|
||||
if let Err(_) = squared_dist {
|
||||
let matrix1: ComputedMatrix = self.to_transform_3d_matrix(None).ok_or(())?.into();
|
||||
let matrix2: ComputedMatrix = other.to_transform_3d_matrix(None).ok_or(())?.into();
|
||||
return matrix1.compute_squared_distance(&matrix2);
|
||||
}
|
||||
squared_dist
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue