1use super::{Property, PropertyId};
4use crate::context::PropertyHandlerContext;
5use crate::declaration::DeclarationList;
6use crate::error::{ParserError, PrinterError};
7use crate::macros::enum_property;
8use crate::prefixes::Feature;
9use crate::traits::{Parse, PropertyHandler, ToCss, Zero};
10use crate::values::number::NonNegative;
11use crate::values::{
12 angle::Angle,
13 length::{Length, LengthPercentage},
14 percentage::NumberOrPercentage,
15};
16use crate::vendor_prefix::VendorPrefix;
17#[cfg(feature = "visitor")]
18use crate::visitor::Visit;
19use cssparser::*;
20use std::f32::consts::PI;
21
22#[derive(Debug, Clone, PartialEq, Default)]
24#[cfg_attr(feature = "visitor", derive(Visit))]
25#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(transparent))]
26#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
27#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
28pub struct TransformList(pub Vec<Transform>);
29
30impl<'i> Parse<'i> for TransformList {
31 fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
32 if input.try_parse(|input| input.expect_ident_matching("none")).is_ok() {
33 return Ok(TransformList(vec![]));
34 }
35
36 input.skip_whitespace();
37 let mut results = vec![Transform::parse(input)?];
38 loop {
39 input.skip_whitespace();
40 if let Ok(item) = input.try_parse(Transform::parse) {
41 results.push(item);
42 } else {
43 return Ok(TransformList(results));
44 }
45 }
46 }
47}
48
49impl ToCss for TransformList {
50 fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
51 if self.0.is_empty() {
52 dest.write_str("none")?;
53 return Ok(());
54 }
55
56 self.to_css_base(dest)
118 }
119}
120
121impl TransformList {
122 fn to_css_base<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
123 let mut first = true;
124 for item in &self.0 {
125 if first {
126 first = false;
127 } else {
128 dest.whitespace()?;
129 }
130 item.to_css(dest)?;
131 }
132 Ok(())
133 }
134
135 pub fn to_matrix(&self) -> Option<Matrix3d<f32>> {
137 let mut matrix = Matrix3d::identity();
138 for transform in &self.0 {
139 if let Some(m) = transform.to_matrix() {
140 matrix = m.multiply(&matrix);
141 } else {
142 return None;
143 }
144 }
145 Some(matrix)
146 }
147}
148
149#[derive(Debug, Clone, PartialEq)]
151#[cfg_attr(feature = "visitor", derive(Visit))]
152#[cfg_attr(
153 feature = "serde",
154 derive(serde::Serialize, serde::Deserialize),
155 serde(tag = "type", content = "value", rename_all = "camelCase")
156)]
157#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
158#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
159pub enum Transform {
160 Translate(LengthPercentage, LengthPercentage),
162 TranslateX(LengthPercentage),
164 TranslateY(LengthPercentage),
166 TranslateZ(Length),
168 Translate3d(LengthPercentage, LengthPercentage, Length),
170 Scale(NumberOrPercentage, NumberOrPercentage),
172 ScaleX(NumberOrPercentage),
174 ScaleY(NumberOrPercentage),
176 ScaleZ(NumberOrPercentage),
178 Scale3d(NumberOrPercentage, NumberOrPercentage, NumberOrPercentage),
180 Rotate(Angle),
182 RotateX(Angle),
184 RotateY(Angle),
186 RotateZ(Angle),
188 Rotate3d(f32, f32, f32, Angle),
190 Skew(Angle, Angle),
192 SkewX(Angle),
194 SkewY(Angle),
196 Perspective(NonNegative<Length>),
198 Matrix(Matrix<f32>),
200 Matrix3d(Matrix3d<f32>),
202}
203
204#[derive(Debug, Clone, PartialEq)]
206#[cfg_attr(feature = "visitor", derive(Visit))]
207#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
208#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
209#[allow(missing_docs)]
210#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
211pub struct Matrix<T> {
212 pub a: T,
213 pub b: T,
214 pub c: T,
215 pub d: T,
216 pub e: T,
217 pub f: T,
218}
219
220impl Matrix<f32> {
221 pub fn to_matrix3d(&self) -> Matrix3d<f32> {
223 Matrix3d {
224 m11: self.a,
225 m12: self.b,
226 m13: 0.0,
227 m14: 0.0,
228 m21: self.c,
229 m22: self.d,
230 m23: 0.0,
231 m24: 0.0,
232 m31: 0.0,
233 m32: 0.0,
234 m33: 1.0,
235 m34: 0.0,
236 m41: self.e,
237 m42: self.f,
238 m43: 0.0,
239 m44: 1.0,
240 }
241 }
242}
243
244#[derive(Debug, Clone, PartialEq)]
246#[cfg_attr(feature = "visitor", derive(Visit))]
247#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
248#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
249#[allow(missing_docs)]
250pub struct Matrix3d<T> {
251 pub m11: T,
252 pub m12: T,
253 pub m13: T,
254 pub m14: T,
255 pub m21: T,
256 pub m22: T,
257 pub m23: T,
258 pub m24: T,
259 pub m31: T,
260 pub m32: T,
261 pub m33: T,
262 pub m34: T,
263 pub m41: T,
264 pub m42: T,
265 pub m43: T,
266 pub m44: T,
267}
268
269impl Matrix3d<f32> {
271 pub fn identity() -> Matrix3d<f32> {
273 Matrix3d {
274 m11: 1.0,
275 m12: 0.0,
276 m13: 0.0,
277 m14: 0.0,
278 m21: 0.0,
279 m22: 1.0,
280 m23: 0.0,
281 m24: 0.0,
282 m31: 0.0,
283 m32: 0.0,
284 m33: 1.0,
285 m34: 0.0,
286 m41: 0.0,
287 m42: 0.0,
288 m43: 0.0,
289 m44: 1.0,
290 }
291 }
292
293 pub fn translate(x: f32, y: f32, z: f32) -> Matrix3d<f32> {
295 Matrix3d {
296 m11: 1.0,
297 m12: 0.0,
298 m13: 0.0,
299 m14: 0.0,
300 m21: 0.0,
301 m22: 1.0,
302 m23: 0.0,
303 m24: 0.0,
304 m31: 0.0,
305 m32: 0.0,
306 m33: 1.0,
307 m34: 0.0,
308 m41: x,
309 m42: y,
310 m43: z,
311 m44: 1.0,
312 }
313 }
314
315 pub fn scale(x: f32, y: f32, z: f32) -> Matrix3d<f32> {
317 Matrix3d {
318 m11: x,
319 m12: 0.0,
320 m13: 0.0,
321 m14: 0.0,
322 m21: 0.0,
323 m22: y,
324 m23: 0.0,
325 m24: 0.0,
326 m31: 0.0,
327 m32: 0.0,
328 m33: z,
329 m34: 0.0,
330 m41: 0.0,
331 m42: 0.0,
332 m43: 0.0,
333 m44: 1.0,
334 }
335 }
336
337 pub fn rotate(x: f32, y: f32, z: f32, angle: f32) -> Matrix3d<f32> {
339 let length = (x * x + y * y + z * z).sqrt();
341 if length == 0.0 {
342 return Matrix3d::identity();
344 }
345
346 let x = x / length;
347 let y = y / length;
348 let z = z / length;
349
350 let half_angle = angle / 2.0;
351 let sin = half_angle.sin();
352 let sc = sin * half_angle.cos();
353 let sq = sin * sin;
354 let m11 = 1.0 - 2.0 * (y * y + z * z) * sq;
355 let m12 = 2.0 * (x * y * sq + z * sc);
356 let m13 = 2.0 * (x * z * sq - y * sc);
357 let m21 = 2.0 * (x * y * sq - z * sc);
358 let m22 = 1.0 - 2.0 * (x * x + z * z) * sq;
359 let m23 = 2.0 * (y * z * sq + x * sc);
360 let m31 = 2.0 * (x * z * sq + y * sc);
361 let m32 = 2.0 * (y * z * sq - x * sc);
362 let m33 = 1.0 - 2.0 * (x * x + y * y) * sq;
363 Matrix3d {
364 m11,
365 m12,
366 m13,
367 m14: 0.0,
368 m21,
369 m22,
370 m23,
371 m24: 0.0,
372 m31,
373 m32,
374 m33,
375 m34: 0.0,
376 m41: 0.0,
377 m42: 0.0,
378 m43: 0.0,
379 m44: 1.0,
380 }
381 }
382
383 pub fn skew(a: f32, b: f32) -> Matrix3d<f32> {
385 Matrix3d {
386 m11: 1.0,
387 m12: b.tan(),
388 m13: 0.0,
389 m14: 0.0,
390 m21: a.tan(),
391 m22: 1.0,
392 m23: 0.0,
393 m24: 0.0,
394 m31: 0.0,
395 m32: 0.0,
396 m33: 1.0,
397 m34: 0.0,
398 m41: 0.0,
399 m42: 0.0,
400 m43: 0.0,
401 m44: 1.0,
402 }
403 }
404
405 pub fn perspective(d: f32) -> Matrix3d<f32> {
407 Matrix3d {
408 m11: 1.0,
409 m12: 0.0,
410 m13: 0.0,
411 m14: 0.0,
412 m21: 0.0,
413 m22: 1.0,
414 m23: 0.0,
415 m24: 0.0,
416 m31: 0.0,
417 m32: 0.0,
418 m33: 1.0,
419 m34: -1.0 / d,
420 m41: 0.0,
421 m42: 0.0,
422 m43: 0.0,
423 m44: 1.0,
424 }
425 }
426
427 pub fn multiply(&self, other: &Self) -> Self {
429 Matrix3d {
430 m11: self.m11 * other.m11 + self.m12 * other.m21 + self.m13 * other.m31 + self.m14 * other.m41,
431 m12: self.m11 * other.m12 + self.m12 * other.m22 + self.m13 * other.m32 + self.m14 * other.m42,
432 m13: self.m11 * other.m13 + self.m12 * other.m23 + self.m13 * other.m33 + self.m14 * other.m43,
433 m14: self.m11 * other.m14 + self.m12 * other.m24 + self.m13 * other.m34 + self.m14 * other.m44,
434 m21: self.m21 * other.m11 + self.m22 * other.m21 + self.m23 * other.m31 + self.m24 * other.m41,
435 m22: self.m21 * other.m12 + self.m22 * other.m22 + self.m23 * other.m32 + self.m24 * other.m42,
436 m23: self.m21 * other.m13 + self.m22 * other.m23 + self.m23 * other.m33 + self.m24 * other.m43,
437 m24: self.m21 * other.m14 + self.m22 * other.m24 + self.m23 * other.m34 + self.m24 * other.m44,
438 m31: self.m31 * other.m11 + self.m32 * other.m21 + self.m33 * other.m31 + self.m34 * other.m41,
439 m32: self.m31 * other.m12 + self.m32 * other.m22 + self.m33 * other.m32 + self.m34 * other.m42,
440 m33: self.m31 * other.m13 + self.m32 * other.m23 + self.m33 * other.m33 + self.m34 * other.m43,
441 m34: self.m31 * other.m14 + self.m32 * other.m24 + self.m33 * other.m34 + self.m34 * other.m44,
442 m41: self.m41 * other.m11 + self.m42 * other.m21 + self.m43 * other.m31 + self.m44 * other.m41,
443 m42: self.m41 * other.m12 + self.m42 * other.m22 + self.m43 * other.m32 + self.m44 * other.m42,
444 m43: self.m41 * other.m13 + self.m42 * other.m23 + self.m43 * other.m33 + self.m44 * other.m43,
445 m44: self.m41 * other.m14 + self.m42 * other.m24 + self.m43 * other.m34 + self.m44 * other.m44,
446 }
447 }
448
449 pub fn is_2d(&self) -> bool {
451 self.m31 == 0.0
452 && self.m32 == 0.0
453 && self.m13 == 0.0
454 && self.m23 == 0.0
455 && self.m43 == 0.0
456 && self.m14 == 0.0
457 && self.m24 == 0.0
458 && self.m34 == 0.0
459 && self.m33 == 1.0
460 && self.m44 == 1.0
461 }
462
463 pub fn to_matrix2d(&self) -> Option<Matrix<f32>> {
466 if self.is_2d() {
467 return Some(Matrix {
468 a: self.m11,
469 b: self.m12,
470 c: self.m21,
471 d: self.m22,
472 e: self.m41,
473 f: self.m42,
474 });
475 }
476 None
477 }
478
479 pub fn scale_by_factor(&mut self, scaling_factor: f32) {
481 self.m11 *= scaling_factor;
482 self.m12 *= scaling_factor;
483 self.m13 *= scaling_factor;
484 self.m14 *= scaling_factor;
485 self.m21 *= scaling_factor;
486 self.m22 *= scaling_factor;
487 self.m23 *= scaling_factor;
488 self.m24 *= scaling_factor;
489 self.m31 *= scaling_factor;
490 self.m32 *= scaling_factor;
491 self.m33 *= scaling_factor;
492 self.m34 *= scaling_factor;
493 self.m41 *= scaling_factor;
494 self.m42 *= scaling_factor;
495 self.m43 *= scaling_factor;
496 self.m44 *= scaling_factor;
497 }
498
499 pub fn determinant(&self) -> f32 {
501 self.m14 * self.m23 * self.m32 * self.m41
502 - self.m13 * self.m24 * self.m32 * self.m41
503 - self.m14 * self.m22 * self.m33 * self.m41
504 + self.m12 * self.m24 * self.m33 * self.m41
505 + self.m13 * self.m22 * self.m34 * self.m41
506 - self.m12 * self.m23 * self.m34 * self.m41
507 - self.m14 * self.m23 * self.m31 * self.m42
508 + self.m13 * self.m24 * self.m31 * self.m42
509 + self.m14 * self.m21 * self.m33 * self.m42
510 - self.m11 * self.m24 * self.m33 * self.m42
511 - self.m13 * self.m21 * self.m34 * self.m42
512 + self.m11 * self.m23 * self.m34 * self.m42
513 + self.m14 * self.m22 * self.m31 * self.m43
514 - self.m12 * self.m24 * self.m31 * self.m43
515 - self.m14 * self.m21 * self.m32 * self.m43
516 + self.m11 * self.m24 * self.m32 * self.m43
517 + self.m12 * self.m21 * self.m34 * self.m43
518 - self.m11 * self.m22 * self.m34 * self.m43
519 - self.m13 * self.m22 * self.m31 * self.m44
520 + self.m12 * self.m23 * self.m31 * self.m44
521 + self.m13 * self.m21 * self.m32 * self.m44
522 - self.m11 * self.m23 * self.m32 * self.m44
523 - self.m12 * self.m21 * self.m33 * self.m44
524 + self.m11 * self.m22 * self.m33 * self.m44
525 }
526
527 pub fn inverse(&self) -> Option<Matrix3d<f32>> {
529 let mut det = self.determinant();
530 if det == 0.0 {
531 return None;
532 }
533
534 det = 1.0 / det;
535 Some(Matrix3d {
536 m11: det
537 * (self.m23 * self.m34 * self.m42 - self.m24 * self.m33 * self.m42 + self.m24 * self.m32 * self.m43
538 - self.m22 * self.m34 * self.m43
539 - self.m23 * self.m32 * self.m44
540 + self.m22 * self.m33 * self.m44),
541 m12: det
542 * (self.m14 * self.m33 * self.m42 - self.m13 * self.m34 * self.m42 - self.m14 * self.m32 * self.m43
543 + self.m12 * self.m34 * self.m43
544 + self.m13 * self.m32 * self.m44
545 - self.m12 * self.m33 * self.m44),
546 m13: det
547 * (self.m13 * self.m24 * self.m42 - self.m14 * self.m23 * self.m42 + self.m14 * self.m22 * self.m43
548 - self.m12 * self.m24 * self.m43
549 - self.m13 * self.m22 * self.m44
550 + self.m12 * self.m23 * self.m44),
551 m14: det
552 * (self.m14 * self.m23 * self.m32 - self.m13 * self.m24 * self.m32 - self.m14 * self.m22 * self.m33
553 + self.m12 * self.m24 * self.m33
554 + self.m13 * self.m22 * self.m34
555 - self.m12 * self.m23 * self.m34),
556 m21: det
557 * (self.m24 * self.m33 * self.m41 - self.m23 * self.m34 * self.m41 - self.m24 * self.m31 * self.m43
558 + self.m21 * self.m34 * self.m43
559 + self.m23 * self.m31 * self.m44
560 - self.m21 * self.m33 * self.m44),
561 m22: det
562 * (self.m13 * self.m34 * self.m41 - self.m14 * self.m33 * self.m41 + self.m14 * self.m31 * self.m43
563 - self.m11 * self.m34 * self.m43
564 - self.m13 * self.m31 * self.m44
565 + self.m11 * self.m33 * self.m44),
566 m23: det
567 * (self.m14 * self.m23 * self.m41 - self.m13 * self.m24 * self.m41 - self.m14 * self.m21 * self.m43
568 + self.m11 * self.m24 * self.m43
569 + self.m13 * self.m21 * self.m44
570 - self.m11 * self.m23 * self.m44),
571 m24: det
572 * (self.m13 * self.m24 * self.m31 - self.m14 * self.m23 * self.m31 + self.m14 * self.m21 * self.m33
573 - self.m11 * self.m24 * self.m33
574 - self.m13 * self.m21 * self.m34
575 + self.m11 * self.m23 * self.m34),
576 m31: det
577 * (self.m22 * self.m34 * self.m41 - self.m24 * self.m32 * self.m41 + self.m24 * self.m31 * self.m42
578 - self.m21 * self.m34 * self.m42
579 - self.m22 * self.m31 * self.m44
580 + self.m21 * self.m32 * self.m44),
581 m32: det
582 * (self.m14 * self.m32 * self.m41 - self.m12 * self.m34 * self.m41 - self.m14 * self.m31 * self.m42
583 + self.m11 * self.m34 * self.m42
584 + self.m12 * self.m31 * self.m44
585 - self.m11 * self.m32 * self.m44),
586 m33: det
587 * (self.m12 * self.m24 * self.m41 - self.m14 * self.m22 * self.m41 + self.m14 * self.m21 * self.m42
588 - self.m11 * self.m24 * self.m42
589 - self.m12 * self.m21 * self.m44
590 + self.m11 * self.m22 * self.m44),
591 m34: det
592 * (self.m14 * self.m22 * self.m31 - self.m12 * self.m24 * self.m31 - self.m14 * self.m21 * self.m32
593 + self.m11 * self.m24 * self.m32
594 + self.m12 * self.m21 * self.m34
595 - self.m11 * self.m22 * self.m34),
596 m41: det
597 * (self.m23 * self.m32 * self.m41 - self.m22 * self.m33 * self.m41 - self.m23 * self.m31 * self.m42
598 + self.m21 * self.m33 * self.m42
599 + self.m22 * self.m31 * self.m43
600 - self.m21 * self.m32 * self.m43),
601 m42: det
602 * (self.m12 * self.m33 * self.m41 - self.m13 * self.m32 * self.m41 + self.m13 * self.m31 * self.m42
603 - self.m11 * self.m33 * self.m42
604 - self.m12 * self.m31 * self.m43
605 + self.m11 * self.m32 * self.m43),
606 m43: det
607 * (self.m13 * self.m22 * self.m41 - self.m12 * self.m23 * self.m41 - self.m13 * self.m21 * self.m42
608 + self.m11 * self.m23 * self.m42
609 + self.m12 * self.m21 * self.m43
610 - self.m11 * self.m22 * self.m43),
611 m44: det
612 * (self.m12 * self.m23 * self.m31 - self.m13 * self.m22 * self.m31 + self.m13 * self.m21 * self.m32
613 - self.m11 * self.m23 * self.m32
614 - self.m12 * self.m21 * self.m33
615 + self.m11 * self.m22 * self.m33),
616 })
617 }
618
619 pub fn transpose(&self) -> Self {
621 Self {
622 m11: self.m11,
623 m12: self.m21,
624 m13: self.m31,
625 m14: self.m41,
626 m21: self.m12,
627 m22: self.m22,
628 m23: self.m32,
629 m24: self.m42,
630 m31: self.m13,
631 m32: self.m23,
632 m33: self.m33,
633 m34: self.m43,
634 m41: self.m14,
635 m42: self.m24,
636 m43: self.m34,
637 m44: self.m44,
638 }
639 }
640
641 pub fn multiply_vector(&self, pin: &[f32; 4]) -> [f32; 4] {
643 [
644 pin[0] * self.m11 + pin[1] * self.m21 + pin[2] * self.m31 + pin[3] * self.m41,
645 pin[0] * self.m12 + pin[1] * self.m22 + pin[2] * self.m32 + pin[3] * self.m42,
646 pin[0] * self.m13 + pin[1] * self.m23 + pin[2] * self.m33 + pin[3] * self.m43,
647 pin[0] * self.m14 + pin[1] * self.m24 + pin[2] * self.m34 + pin[3] * self.m44,
648 ]
649 }
650
651 pub fn decompose(&self) -> Option<TransformList> {
653 let combine = |a: [f32; 3], b: [f32; 3], ascl: f32, bscl: f32| {
656 [
657 (ascl * a[0]) + (bscl * b[0]),
658 (ascl * a[1]) + (bscl * b[1]),
659 (ascl * a[2]) + (bscl * b[2]),
660 ]
661 };
662
663 let dot = |a: [f32; 3], b: [f32; 3]| a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
665
666 let cross = |row1: [f32; 3], row2: [f32; 3]| {
668 [
669 row1[1] * row2[2] - row1[2] * row2[1],
670 row1[2] * row2[0] - row1[0] * row2[2],
671 row1[0] * row2[1] - row1[1] * row2[0],
672 ]
673 };
674
675 if self.m44 == 0.0 {
676 return None;
677 }
678
679 let scaling_factor = self.m44;
680
681 let mut matrix = self.clone();
683 matrix.scale_by_factor(1.0 / scaling_factor);
684
685 let mut perspective_matrix = matrix.clone();
688 perspective_matrix.m14 = 0.0;
689 perspective_matrix.m24 = 0.0;
690 perspective_matrix.m34 = 0.0;
691 perspective_matrix.m44 = 1.0;
692
693 if perspective_matrix.determinant() == 0.0 {
694 return None;
695 }
696
697 let mut transforms = vec![];
698
699 if matrix.m14 != 0.0 || matrix.m24 != 0.0 || matrix.m34 != 0.0 {
701 let right_hand_side: [f32; 4] = [matrix.m14, matrix.m24, matrix.m34, matrix.m44];
702
703 perspective_matrix = perspective_matrix.inverse().unwrap().transpose();
704 let perspective = perspective_matrix.multiply_vector(&right_hand_side);
705 if perspective[0] == 0.0 && perspective[1] == 0.0 && perspective[3] == 0.0 {
706 transforms.push(Transform::Perspective(NonNegative(Length::px(-1.0 / perspective[2]))))
707 } else {
708 return None;
709 }
710 }
711
712 if matrix.m41 != 0.0 || matrix.m42 != 0.0 || matrix.m43 != 0.0 {
715 transforms.push(Transform::Translate3d(
716 LengthPercentage::px(matrix.m41),
717 LengthPercentage::px(matrix.m42),
718 Length::px(matrix.m43),
719 ));
720 }
721
722 let mut row = [
724 [matrix.m11, matrix.m12, matrix.m13],
725 [matrix.m21, matrix.m22, matrix.m23],
726 [matrix.m31, matrix.m32, matrix.m33],
727 ];
728
729 let row0len = (row[0][0] * row[0][0] + row[0][1] * row[0][1] + row[0][2] * row[0][2]).sqrt();
731 let mut scale_x = row0len;
732 row[0] = [row[0][0] / row0len, row[0][1] / row0len, row[0][2] / row0len];
733
734 let mut skew_x = dot(row[0], row[1]);
736 row[1] = combine(row[1], row[0], 1.0, -skew_x);
737
738 let row1len = (row[1][0] * row[1][0] + row[1][1] * row[1][1] + row[1][2] * row[1][2]).sqrt();
740 let mut scale_y = row1len;
741 row[1] = [row[1][0] / row1len, row[1][1] / row1len, row[1][2] / row1len];
742 skew_x /= scale_y;
743
744 let mut skew_y = dot(row[0], row[2]);
746 row[2] = combine(row[2], row[0], 1.0, -skew_y);
747 let mut skew_z = dot(row[1], row[2]);
748 row[2] = combine(row[2], row[1], 1.0, -skew_z);
749
750 let row2len = (row[2][0] * row[2][0] + row[2][1] * row[2][1] + row[2][2] * row[2][2]).sqrt();
752 let mut scale_z = row2len;
753 row[2] = [row[2][0] / row2len, row[2][1] / row2len, row[2][2] / row2len];
754 skew_y /= scale_z;
755 skew_z /= scale_z;
756
757 if skew_z != 0.0 {
758 return None; }
760
761 macro_rules! round {
763 ($var: ident) => {
764 $var = ($var * 100000.0).round() / 100000.0;
765 };
766 }
767
768 round!(skew_x);
769 round!(skew_y);
770 round!(skew_z);
771
772 if skew_x != 0.0 || skew_y != 0.0 || skew_z != 0.0 {
773 transforms.push(Transform::Skew(Angle::Rad(skew_x), Angle::Rad(skew_y)));
774 }
775
776 if dot(row[0], cross(row[1], row[2])) < 0.0 {
780 scale_x = -scale_x;
781 scale_y = -scale_y;
782 scale_z = -scale_z;
783 for i in 0..3 {
784 row[i][0] *= -1.0;
785 row[i][1] *= -1.0;
786 row[i][2] *= -1.0;
787 }
788 }
789
790 round!(scale_x);
791 round!(scale_y);
792 round!(scale_z);
793
794 if scale_x != 1.0 || scale_y != 1.0 || scale_z != 1.0 {
795 transforms.push(Transform::Scale3d(
796 NumberOrPercentage::Number(scale_x),
797 NumberOrPercentage::Number(scale_y),
798 NumberOrPercentage::Number(scale_z),
799 ))
800 }
801
802 let mut rotate_x = 0.5 * ((1.0 + row[0][0] - row[1][1] - row[2][2]).max(0.0)).sqrt();
804 let mut rotate_y = 0.5 * ((1.0 - row[0][0] + row[1][1] - row[2][2]).max(0.0)).sqrt();
805 let mut rotate_z = 0.5 * ((1.0 - row[0][0] - row[1][1] + row[2][2]).max(0.0)).sqrt();
806 let rotate_w = 0.5 * ((1.0 + row[0][0] + row[1][1] + row[2][2]).max(0.0)).sqrt();
807
808 if row[2][1] > row[1][2] {
809 rotate_x = -rotate_x
810 }
811
812 if row[0][2] > row[2][0] {
813 rotate_y = -rotate_y
814 }
815
816 if row[1][0] > row[0][1] {
817 rotate_z = -rotate_z
818 }
819
820 let len = (rotate_x * rotate_x + rotate_y * rotate_y + rotate_z * rotate_z).sqrt();
821 if len != 0.0 {
822 rotate_x /= len;
823 rotate_y /= len;
824 rotate_z /= len;
825 }
826 let a = 2.0 * len.atan2(rotate_w);
827
828 let max = rotate_x.max(rotate_y).max(rotate_z);
830 rotate_x /= max;
831 rotate_y /= max;
832 rotate_z /= max;
833
834 if a != 0.0 {
835 transforms.push(Transform::Rotate3d(rotate_x, rotate_y, rotate_z, Angle::Rad(a)))
836 }
837
838 if transforms.is_empty() {
839 return None;
840 }
841
842 Some(TransformList(transforms))
843 }
844}
845
846impl<'i> Parse<'i> for Transform {
847 fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
848 let function = input.expect_function()?.clone();
849 input.parse_nested_block(|input| {
850 let location = input.current_source_location();
851 match_ignore_ascii_case! { &function,
852 "matrix" => {
853 let a = f32::parse(input)?;
854 input.expect_comma()?;
855 let b = f32::parse(input)?;
856 input.expect_comma()?;
857 let c = f32::parse(input)?;
858 input.expect_comma()?;
859 let d = f32::parse(input)?;
860 input.expect_comma()?;
861 let e = f32::parse(input)?;
862 input.expect_comma()?;
863 let f = f32::parse(input)?;
864 Ok(Transform::Matrix(Matrix { a, b, c, d, e, f }))
865 },
866 "matrix3d" => {
867 let m11 = f32::parse(input)?;
868 input.expect_comma()?;
869 let m12 = f32::parse(input)?;
870 input.expect_comma()?;
871 let m13 = f32::parse(input)?;
872 input.expect_comma()?;
873 let m14 = f32::parse(input)?;
874 input.expect_comma()?;
875 let m21 = f32::parse(input)?;
876 input.expect_comma()?;
877 let m22 = f32::parse(input)?;
878 input.expect_comma()?;
879 let m23 = f32::parse(input)?;
880 input.expect_comma()?;
881 let m24 = f32::parse(input)?;
882 input.expect_comma()?;
883 let m31 = f32::parse(input)?;
884 input.expect_comma()?;
885 let m32 = f32::parse(input)?;
886 input.expect_comma()?;
887 let m33 = f32::parse(input)?;
888 input.expect_comma()?;
889 let m34 = f32::parse(input)?;
890 input.expect_comma()?;
891 let m41 = f32::parse(input)?;
892 input.expect_comma()?;
893 let m42 = f32::parse(input)?;
894 input.expect_comma()?;
895 let m43 = f32::parse(input)?;
896 input.expect_comma()?;
897 let m44 = f32::parse(input)?;
898 Ok(Transform::Matrix3d(Matrix3d {
899 m11, m12, m13, m14,
900 m21, m22, m23, m24,
901 m31, m32, m33, m34,
902 m41, m42, m43, m44
903 }))
904 },
905 "translate" => {
906 let x = LengthPercentage::parse(input)?;
907 if input.try_parse(|input| input.expect_comma()).is_ok() {
908 let y = LengthPercentage::parse(input)?;
909 Ok(Transform::Translate(x, y))
910 } else {
911 Ok(Transform::Translate(x, LengthPercentage::zero()))
912 }
913 },
914 "translatex" => {
915 let x = LengthPercentage::parse(input)?;
916 Ok(Transform::TranslateX(x))
917 },
918 "translatey" => {
919 let y = LengthPercentage::parse(input)?;
920 Ok(Transform::TranslateY(y))
921 },
922 "translatez" => {
923 let z = Length::parse(input)?;
924 Ok(Transform::TranslateZ(z))
925 },
926 "translate3d" => {
927 let x = LengthPercentage::parse(input)?;
928 input.expect_comma()?;
929 let y = LengthPercentage::parse(input)?;
930 input.expect_comma()?;
931 let z = Length::parse(input)?;
932 Ok(Transform::Translate3d(x, y, z))
933 },
934 "scale" => {
935 let x = convert_percentage_to_number(input)?;
936 if input.try_parse(|input| input.expect_comma()).is_ok() {
937 let y = convert_percentage_to_number(input)?;
938 Ok(Transform::Scale(x, y))
939 } else {
940 Ok(Transform::Scale(x.clone(), x))
941 }
942 },
943 "scalex" => {
944 let x = convert_percentage_to_number(input)?;
945 Ok(Transform::ScaleX(x))
946 },
947 "scaley" => {
948 let y = convert_percentage_to_number(input)?;
949 Ok(Transform::ScaleY(y))
950 },
951 "scalez" => {
952 let z = convert_percentage_to_number(input)?;
953 Ok(Transform::ScaleZ(z))
954 },
955 "scale3d" => {
956 let x = convert_percentage_to_number(input)?;
957 input.expect_comma()?;
958 let y = convert_percentage_to_number(input)?;
959 input.expect_comma()?;
960 let z = convert_percentage_to_number(input)?;
961 Ok(Transform::Scale3d(x, y, z))
962 },
963 "rotate" => {
964 let angle = Angle::parse_with_unitless_zero(input)?;
965 Ok(Transform::Rotate(angle))
966 },
967 "rotatex" => {
968 let angle = Angle::parse_with_unitless_zero(input)?;
969 Ok(Transform::RotateX(angle))
970 },
971 "rotatey" => {
972 let angle = Angle::parse_with_unitless_zero(input)?;
973 Ok(Transform::RotateY(angle))
974 },
975 "rotatez" => {
976 let angle = Angle::parse_with_unitless_zero(input)?;
977 Ok(Transform::RotateZ(angle))
978 },
979 "rotate3d" => {
980 let x = f32::parse(input)?;
981 input.expect_comma()?;
982 let y = f32::parse(input)?;
983 input.expect_comma()?;
984 let z = f32::parse(input)?;
985 input.expect_comma()?;
986 let angle = Angle::parse_with_unitless_zero(input)?;
987 Ok(Transform::Rotate3d(x, y, z, angle))
988 },
989 "skew" => {
990 let x = Angle::parse_with_unitless_zero(input)?;
991 if input.try_parse(|input| input.expect_comma()).is_ok() {
992 let y = Angle::parse_with_unitless_zero(input)?;
993 Ok(Transform::Skew(x, y))
994 } else {
995 Ok(Transform::Skew(x, Angle::Deg(0.0)))
996 }
997 },
998 "skewx" => {
999 let angle = Angle::parse_with_unitless_zero(input)?;
1000 Ok(Transform::SkewX(angle))
1001 },
1002 "skewy" => {
1003 let angle = Angle::parse_with_unitless_zero(input)?;
1004 Ok(Transform::SkewY(angle))
1005 },
1006 "perspective" => {
1007 let len = NonNegative::<Length>::parse(input)?;
1008 Ok(Transform::Perspective(len))
1009 },
1010 _ => Err(location.new_unexpected_token_error(
1011 cssparser::Token::Ident(function.clone())
1012 ))
1013 }
1014 })
1015 }
1016}
1017
1018impl ToCss for Transform {
1019 fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1020 use Transform::*;
1021 match self {
1022 Translate(x, y) => {
1023 if dest.options().minify && x.is_zero() && !y.is_zero() {
1024 dest.write_str("translateY(")?;
1025 y.to_css(dest)?
1026 } else {
1027 dest.write_str("translate(")?;
1028 x.to_css(dest)?;
1029 if !y.is_zero() {
1030 dest.delim(',', false)?;
1031 y.to_css(dest)?;
1032 }
1033 }
1034 dest.write_char(')')?;
1035 Ok(())
1036 }
1037 TranslateX(x) => {
1038 dest.write_str(if dest.options().minify {
1039 "translate("
1040 } else {
1041 "translateX("
1042 })?;
1043 x.to_css(dest)?;
1044 dest.write_char(')')?;
1045 Ok(())
1046 }
1047 TranslateY(y) => {
1048 dest.write_str("translateY(")?;
1049 y.to_css(dest)?;
1050 dest.write_char(')')?;
1051 Ok(())
1052 }
1053 TranslateZ(z) => {
1054 dest.write_str("translateZ(")?;
1055 z.to_css(dest)?;
1056 dest.write_char(')')?;
1057 Ok(())
1058 }
1059 Translate3d(x, y, z) => {
1060 if dest.options().minify && y.is_zero() && z.is_zero() {
1061 dest.write_str("translate(")?;
1062 x.to_css(dest)?;
1063 } else if dest.options().minify && x.is_zero() && !y.is_zero() && z.is_zero() {
1064 dest.write_str("translateY(")?;
1065 y.to_css(dest)?;
1066 } else if dest.options().minify && x.is_zero() && y.is_zero() && !z.is_zero() {
1067 dest.write_str("translateZ(")?;
1068 z.to_css(dest)?;
1069 } else if dest.options().minify && z.is_zero() {
1070 dest.write_str("translate(")?;
1071 x.to_css(dest)?;
1072 dest.delim(',', false)?;
1073 y.to_css(dest)?;
1074 } else {
1075 dest.write_str("translate3d(")?;
1076 x.to_css(dest)?;
1077 dest.delim(',', false)?;
1078 y.to_css(dest)?;
1079 dest.delim(',', false)?;
1080 z.to_css(dest)?;
1081 }
1082 dest.write_char(')')?;
1083 Ok(())
1084 }
1085 Scale(x, y) => {
1086 let x: f32 = x.into();
1087 let y: f32 = y.into();
1088 if dest.options().minify && x == 1.0 && y != 1.0 {
1089 dest.write_str("scaleY(")?;
1090 y.to_css(dest)?;
1091 } else if dest.options().minify && x != 1.0 && y == 1.0 {
1092 dest.write_str("scaleX(")?;
1093 x.to_css(dest)?;
1094 } else {
1095 dest.write_str("scale(")?;
1096 x.to_css(dest)?;
1097 if y != x {
1098 dest.delim(',', false)?;
1099 y.to_css(dest)?;
1100 }
1101 }
1102 dest.write_char(')')?;
1103 Ok(())
1104 }
1105 ScaleX(x) => {
1106 let x: f32 = x.into();
1107 dest.write_str("scaleX(")?;
1108 x.to_css(dest)?;
1109 dest.write_char(')')?;
1110 Ok(())
1111 }
1112 ScaleY(y) => {
1113 let y: f32 = y.into();
1114 dest.write_str("scaleY(")?;
1115 y.to_css(dest)?;
1116 dest.write_char(')')?;
1117 Ok(())
1118 }
1119 ScaleZ(z) => {
1120 let z: f32 = z.into();
1121 dest.write_str("scaleZ(")?;
1122 z.to_css(dest)?;
1123 dest.write_char(')')?;
1124 Ok(())
1125 }
1126 Scale3d(x, y, z) => {
1127 let x: f32 = x.into();
1128 let y: f32 = y.into();
1129 let z: f32 = z.into();
1130 if dest.options().minify && z == 1.0 && x == y {
1131 dest.write_str("scale(")?;
1133 x.to_css(dest)?;
1134 } else if dest.options().minify && x != 1.0 && y == 1.0 && z == 1.0 {
1135 dest.write_str("scaleX(")?;
1137 x.to_css(dest)?;
1138 } else if dest.options().minify && x == 1.0 && y != 1.0 && z == 1.0 {
1139 dest.write_str("scaleY(")?;
1141 y.to_css(dest)?;
1142 } else if dest.options().minify && x == 1.0 && y == 1.0 && z != 1.0 {
1143 dest.write_str("scaleZ(")?;
1145 z.to_css(dest)?;
1146 } else if dest.options().minify && z == 1.0 {
1147 dest.write_str("scale(")?;
1149 x.to_css(dest)?;
1150 dest.delim(',', false)?;
1151 y.to_css(dest)?;
1152 } else {
1153 dest.write_str("scale3d(")?;
1154 x.to_css(dest)?;
1155 dest.delim(',', false)?;
1156 y.to_css(dest)?;
1157 dest.delim(',', false)?;
1158 z.to_css(dest)?;
1159 }
1160 dest.write_char(')')?;
1161 Ok(())
1162 }
1163 Rotate(angle) => {
1164 dest.write_str("rotate(")?;
1165 angle.to_css_with_unitless_zero(dest)?;
1166 dest.write_char(')')?;
1167 Ok(())
1168 }
1169 RotateX(angle) => {
1170 dest.write_str("rotateX(")?;
1171 angle.to_css_with_unitless_zero(dest)?;
1172 dest.write_char(')')?;
1173 Ok(())
1174 }
1175 RotateY(angle) => {
1176 dest.write_str("rotateY(")?;
1177 angle.to_css_with_unitless_zero(dest)?;
1178 dest.write_char(')')?;
1179 Ok(())
1180 }
1181 RotateZ(angle) => {
1182 dest.write_str(if dest.options().minify { "rotate(" } else { "rotateZ(" })?;
1183 angle.to_css_with_unitless_zero(dest)?;
1184 dest.write_char(')')?;
1185 Ok(())
1186 }
1187 Rotate3d(x, y, z, angle) => {
1188 if dest.options().minify && *x == 1.0 && *y == 0.0 && *z == 0.0 {
1189 dest.write_str("rotateX(")?;
1191 angle.to_css_with_unitless_zero(dest)?;
1192 } else if dest.options().minify && *x == 0.0 && *y == 1.0 && *z == 0.0 {
1193 dest.write_str("rotateY(")?;
1195 angle.to_css_with_unitless_zero(dest)?;
1196 } else if dest.options().minify && *x == 0.0 && *y == 0.0 && *z == 1.0 {
1197 dest.write_str("rotate(")?;
1199 angle.to_css_with_unitless_zero(dest)?;
1200 } else {
1201 dest.write_str("rotate3d(")?;
1202 x.to_css(dest)?;
1203 dest.delim(',', false)?;
1204 y.to_css(dest)?;
1205 dest.delim(',', false)?;
1206 z.to_css(dest)?;
1207 dest.delim(',', false)?;
1208 angle.to_css_with_unitless_zero(dest)?;
1209 }
1210 dest.write_char(')')?;
1211 Ok(())
1212 }
1213 Skew(x, y) => {
1214 if dest.options().minify && x.is_zero() && !y.is_zero() {
1215 dest.write_str("skewY(")?;
1216 y.to_css_with_unitless_zero(dest)?
1217 } else {
1218 dest.write_str("skew(")?;
1219 x.to_css(dest)?;
1220 if !y.is_zero() {
1221 dest.delim(',', false)?;
1222 y.to_css_with_unitless_zero(dest)?;
1223 }
1224 }
1225 dest.write_char(')')?;
1226 Ok(())
1227 }
1228 SkewX(angle) => {
1229 dest.write_str(if dest.options().minify { "skew(" } else { "skewX(" })?;
1230 angle.to_css_with_unitless_zero(dest)?;
1231 dest.write_char(')')?;
1232 Ok(())
1233 }
1234 SkewY(angle) => {
1235 dest.write_str("skewY(")?;
1236 angle.to_css_with_unitless_zero(dest)?;
1237 dest.write_char(')')?;
1238 Ok(())
1239 }
1240 Perspective(len) => {
1241 dest.write_str("perspective(")?;
1242 len.to_css(dest)?;
1243 dest.write_char(')')?;
1244 Ok(())
1245 }
1246 Matrix(super::transform::Matrix { a, b, c, d, e, f }) => {
1247 dest.write_str("matrix(")?;
1248 a.to_css(dest)?;
1249 dest.delim(',', false)?;
1250 b.to_css(dest)?;
1251 dest.delim(',', false)?;
1252 c.to_css(dest)?;
1253 dest.delim(',', false)?;
1254 d.to_css(dest)?;
1255 dest.delim(',', false)?;
1256 e.to_css(dest)?;
1257 dest.delim(',', false)?;
1258 f.to_css(dest)?;
1259 dest.write_char(')')?;
1260 Ok(())
1261 }
1262 Matrix3d(super::transform::Matrix3d {
1263 m11,
1264 m12,
1265 m13,
1266 m14,
1267 m21,
1268 m22,
1269 m23,
1270 m24,
1271 m31,
1272 m32,
1273 m33,
1274 m34,
1275 m41,
1276 m42,
1277 m43,
1278 m44,
1279 }) => {
1280 dest.write_str("matrix3d(")?;
1281 m11.to_css(dest)?;
1282 dest.delim(',', false)?;
1283 m12.to_css(dest)?;
1284 dest.delim(',', false)?;
1285 m13.to_css(dest)?;
1286 dest.delim(',', false)?;
1287 m14.to_css(dest)?;
1288 dest.delim(',', false)?;
1289 m21.to_css(dest)?;
1290 dest.delim(',', false)?;
1291 m22.to_css(dest)?;
1292 dest.delim(',', false)?;
1293 m23.to_css(dest)?;
1294 dest.delim(',', false)?;
1295 m24.to_css(dest)?;
1296 dest.delim(',', false)?;
1297 m31.to_css(dest)?;
1298 dest.delim(',', false)?;
1299 m32.to_css(dest)?;
1300 dest.delim(',', false)?;
1301 m33.to_css(dest)?;
1302 dest.delim(',', false)?;
1303 m34.to_css(dest)?;
1304 dest.delim(',', false)?;
1305 m41.to_css(dest)?;
1306 dest.delim(',', false)?;
1307 m42.to_css(dest)?;
1308 dest.delim(',', false)?;
1309 m43.to_css(dest)?;
1310 dest.delim(',', false)?;
1311 m44.to_css(dest)?;
1312 dest.write_char(')')?;
1313 Ok(())
1314 }
1315 }
1316 }
1317}
1318
1319impl Transform {
1320 pub fn to_matrix(&self) -> Option<Matrix3d<f32>> {
1322 macro_rules! to_radians {
1323 ($angle: ident) => {{
1324 let rad = $angle.to_radians();
1330 if rad < 0.0 || rad >= 2.0 * PI {
1331 return None;
1332 }
1333
1334 rad
1335 }};
1336 }
1337
1338 match &self {
1339 Transform::Translate(LengthPercentage::Dimension(x), LengthPercentage::Dimension(y)) => {
1340 if let (Some(x), Some(y)) = (x.to_px(), y.to_px()) {
1341 return Some(Matrix3d::translate(x, y, 0.0));
1342 }
1343 }
1344 Transform::TranslateX(LengthPercentage::Dimension(x)) => {
1345 if let Some(x) = x.to_px() {
1346 return Some(Matrix3d::translate(x, 0.0, 0.0));
1347 }
1348 }
1349 Transform::TranslateY(LengthPercentage::Dimension(y)) => {
1350 if let Some(y) = y.to_px() {
1351 return Some(Matrix3d::translate(0.0, y, 0.0));
1352 }
1353 }
1354 Transform::TranslateZ(z) => {
1355 if let Some(z) = z.to_px() {
1356 return Some(Matrix3d::translate(0.0, 0.0, z));
1357 }
1358 }
1359 Transform::Translate3d(LengthPercentage::Dimension(x), LengthPercentage::Dimension(y), z) => {
1360 if let (Some(x), Some(y), Some(z)) = (x.to_px(), y.to_px(), z.to_px()) {
1361 return Some(Matrix3d::translate(x, y, z));
1362 }
1363 }
1364 Transform::Scale(x, y) => return Some(Matrix3d::scale(x.into(), y.into(), 1.0)),
1365 Transform::ScaleX(x) => return Some(Matrix3d::scale(x.into(), 1.0, 1.0)),
1366 Transform::ScaleY(y) => return Some(Matrix3d::scale(1.0, y.into(), 1.0)),
1367 Transform::ScaleZ(z) => return Some(Matrix3d::scale(1.0, 1.0, z.into())),
1368 Transform::Scale3d(x, y, z) => return Some(Matrix3d::scale(x.into(), y.into(), z.into())),
1369 Transform::Rotate(angle) | Transform::RotateZ(angle) => {
1370 return Some(Matrix3d::rotate(0.0, 0.0, 1.0, to_radians!(angle)))
1371 }
1372 Transform::RotateX(angle) => return Some(Matrix3d::rotate(1.0, 0.0, 0.0, to_radians!(angle))),
1373 Transform::RotateY(angle) => return Some(Matrix3d::rotate(0.0, 1.0, 0.0, to_radians!(angle))),
1374 Transform::Rotate3d(x, y, z, angle) => return Some(Matrix3d::rotate(*x, *y, *z, to_radians!(angle))),
1375 Transform::Skew(x, y) => return Some(Matrix3d::skew(to_radians!(x), to_radians!(y))),
1376 Transform::SkewX(x) => return Some(Matrix3d::skew(to_radians!(x), 0.0)),
1377 Transform::SkewY(y) => return Some(Matrix3d::skew(0.0, to_radians!(y))),
1378 Transform::Perspective(len) => {
1379 if let Some(len) = len.0.to_px() {
1380 return Some(Matrix3d::perspective(len));
1381 }
1382 }
1383 Transform::Matrix(m) => return Some(m.to_matrix3d()),
1384 Transform::Matrix3d(m) => return Some(m.clone()),
1385 _ => {}
1386 }
1387 None
1388 }
1389}
1390
1391enum_property! {
1392 #[allow(missing_docs)]
1394 pub enum TransformStyle {
1395 Flat,
1396 Preserve3d,
1397 }
1398}
1399
1400enum_property! {
1401 pub enum TransformBox {
1403 ContentBox,
1405 BorderBox,
1407 FillBox,
1409 StrokeBox,
1411 ViewBox,
1413 }
1414}
1415
1416enum_property! {
1417 #[allow(missing_docs)]
1419 pub enum BackfaceVisibility {
1420 Visible,
1421 Hidden,
1422 }
1423}
1424
1425#[derive(Debug, Clone, PartialEq, Parse, ToCss)]
1427#[cfg_attr(feature = "visitor", derive(Visit))]
1428#[cfg_attr(
1429 feature = "serde",
1430 derive(serde::Serialize, serde::Deserialize),
1431 serde(tag = "type", content = "value", rename_all = "kebab-case")
1432)]
1433#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1434#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1435pub enum Perspective {
1436 None,
1438 Length(NonNegative<Length>),
1440}
1441
1442#[derive(Debug, Clone, PartialEq)]
1444#[cfg_attr(feature = "visitor", derive(Visit))]
1445#[cfg_attr(
1446 feature = "serde",
1447 derive(serde::Serialize, serde::Deserialize),
1448 serde(rename_all = "lowercase")
1449)]
1450#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1451#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1452pub enum Translate {
1453 None,
1455
1456 #[cfg_attr(feature = "serde", serde(untagged))]
1458 XYZ {
1459 x: LengthPercentage,
1461 y: LengthPercentage,
1463 z: Length,
1465 },
1466}
1467
1468impl<'i> Parse<'i> for Translate {
1469 fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
1470 if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
1471 return Ok(Translate::None);
1472 }
1473
1474 let x = LengthPercentage::parse(input)?;
1475 let y = input.try_parse(LengthPercentage::parse);
1476 let z = if y.is_ok() {
1477 input.try_parse(Length::parse).ok()
1478 } else {
1479 None
1480 };
1481
1482 Ok(Translate::XYZ {
1483 x,
1484 y: y.unwrap_or(LengthPercentage::zero()),
1485 z: z.unwrap_or(Length::zero()),
1486 })
1487 }
1488}
1489
1490impl ToCss for Translate {
1491 fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1492 match self {
1493 Translate::None => {
1494 dest.write_str("none")?;
1495 }
1496 Translate::XYZ { x, y, z } => {
1497 x.to_css(dest)?;
1498 if !y.is_zero() || !z.is_zero() {
1499 dest.write_char(' ')?;
1500 y.to_css(dest)?;
1501 if !z.is_zero() {
1502 dest.write_char(' ')?;
1503 z.to_css(dest)?;
1504 }
1505 }
1506 }
1507 };
1508
1509 Ok(())
1510 }
1511}
1512
1513impl Translate {
1514 pub fn to_transform(&self) -> Transform {
1516 match self {
1517 Translate::None => {
1518 Transform::Translate3d(LengthPercentage::zero(), LengthPercentage::zero(), Length::zero())
1519 }
1520 Translate::XYZ { x, y, z } => Transform::Translate3d(x.clone(), y.clone(), z.clone()),
1521 }
1522 }
1523}
1524
1525#[derive(Debug, Clone, PartialEq)]
1527#[cfg_attr(feature = "visitor", derive(Visit))]
1528#[cfg_attr(
1529 feature = "serde",
1530 derive(serde::Serialize, serde::Deserialize),
1531 serde(rename_all = "lowercase")
1532)]
1533#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1534#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1535pub enum Rotate {
1536 None,
1538
1539 #[cfg_attr(feature = "serde", serde(untagged))]
1541 XYZ {
1542 x: f32,
1544 y: f32,
1546 z: f32,
1548 angle: Angle,
1550 },
1551}
1552
1553impl<'i> Parse<'i> for Rotate {
1554 fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
1555 if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
1560 return Ok(Rotate::None);
1561 }
1562
1563 let angle = input.try_parse(Angle::parse);
1564 let (x, y, z) = input
1565 .try_parse(|input| {
1566 let location = input.current_source_location();
1567 let ident = input.expect_ident()?;
1568 match_ignore_ascii_case! { &*ident,
1569 "x" => Ok((1.0, 0.0, 0.0)),
1570 "y" => Ok((0.0, 1.0, 0.0)),
1571 "z" => Ok((0.0, 0.0, 1.0)),
1572 _ => Err(location.new_unexpected_token_error(
1573 cssparser::Token::Ident(ident.clone())
1574 ))
1575 }
1576 })
1577 .or_else(
1578 |_: ParseError<'i, ParserError<'i>>| -> Result<_, ParseError<'i, ParserError<'i>>> {
1579 input.try_parse(|input| Ok((f32::parse(input)?, f32::parse(input)?, f32::parse(input)?)))
1580 },
1581 )
1582 .unwrap_or((0.0, 0.0, 1.0));
1583 let angle = angle.or_else(|_| Angle::parse(input))?;
1584 Ok(Rotate::XYZ { x, y, z, angle })
1585 }
1586}
1587
1588impl ToCss for Rotate {
1589 fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1590 match self {
1591 Rotate::None => {
1592 dest.write_str("none")?;
1593 Ok(())
1594 }
1595 Rotate::XYZ { x, y, z, angle } => {
1596 if *y == 0.0 && *z == 0.0 && *x != 0.0 {
1602 let angle = if *x < 0.0 { angle.clone() * -1.0 } else { angle.clone() };
1603 dest.write_str("x ")?;
1604 angle.to_css(dest)
1605 } else if *x == 0.0 && *z == 0.0 && *y != 0.0 {
1606 let angle = if *y < 0.0 { angle.clone() * -1.0 } else { angle.clone() };
1607 dest.write_str("y ")?;
1608 angle.to_css(dest)
1609 } else if *x == 0.0 && *y == 0.0 && *z != 0.0 {
1610 let angle = if *z < 0.0 { angle.clone() * -1.0 } else { angle.clone() };
1611 angle.to_css(dest)
1612 } else {
1613 x.to_css(dest)?;
1614 dest.write_char(' ')?;
1615 y.to_css(dest)?;
1616 dest.write_char(' ')?;
1617 z.to_css(dest)?;
1618 dest.write_char(' ')?;
1619 angle.to_css(dest)
1620 }
1621 }
1622 }
1623 }
1624}
1625
1626impl Rotate {
1627 pub fn to_transform(&self) -> Transform {
1629 match self {
1630 Rotate::None => Transform::Rotate3d(0.0, 0.0, 1.0, Angle::Deg(0.0)),
1631 Rotate::XYZ { x, y, z, angle } => Transform::Rotate3d(*x, *y, *z, angle.clone()),
1632 }
1633 }
1634}
1635
1636#[derive(Debug, Clone, PartialEq)]
1638#[cfg_attr(feature = "visitor", derive(Visit))]
1639#[cfg_attr(
1640 feature = "serde",
1641 derive(serde::Serialize, serde::Deserialize),
1642 serde(rename_all = "lowercase")
1643)]
1644#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1645#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1646pub enum Scale {
1647 None,
1649
1650 #[cfg_attr(feature = "serde", serde(untagged))]
1652 XYZ {
1653 x: NumberOrPercentage,
1655 y: NumberOrPercentage,
1657 z: NumberOrPercentage,
1659 },
1660}
1661
1662fn convert_percentage_to_number<'i, 't>(
1663 input: &mut Parser<'i, 't>,
1664) -> Result<NumberOrPercentage, ParseError<'i, ParserError<'i>>> {
1665 Ok(match NumberOrPercentage::parse(input)? {
1666 NumberOrPercentage::Number(number) => NumberOrPercentage::Number(number),
1667 NumberOrPercentage::Percentage(percent) => NumberOrPercentage::Number(percent.0),
1668 })
1669}
1670
1671impl<'i> Parse<'i> for Scale {
1672 fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
1673 if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
1674 return Ok(Scale::None);
1675 }
1676
1677 let x = convert_percentage_to_number(input)?;
1678 let y = input.try_parse(convert_percentage_to_number);
1679 let z = if y.is_ok() {
1680 input.try_parse(convert_percentage_to_number).ok()
1681 } else {
1682 None
1683 };
1684
1685 Ok(Scale::XYZ {
1686 x: x.clone(),
1687 y: y.unwrap_or(x),
1688 z: z.unwrap_or(NumberOrPercentage::Number(1.0)),
1689 })
1690 }
1691}
1692
1693impl ToCss for Scale {
1694 fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1695 match self {
1696 Scale::None => {
1697 dest.write_str("none")?;
1698 }
1699 Scale::XYZ { x, y, z } => {
1700 let x: f32 = x.into();
1701 let y: f32 = y.into();
1702 let z: f32 = z.into();
1703 x.to_css(dest)?;
1704 if y != x || z != 1.0 {
1705 dest.write_char(' ')?;
1706 y.to_css(dest)?;
1707 if z != 1.0 {
1708 dest.write_char(' ')?;
1709 z.to_css(dest)?;
1710 }
1711 }
1712 }
1713 }
1714
1715 Ok(())
1716 }
1717}
1718
1719impl Scale {
1720 pub fn to_transform(&self) -> Transform {
1722 match self {
1723 Scale::None => Transform::Scale3d(
1724 NumberOrPercentage::Number(1.0),
1725 NumberOrPercentage::Number(1.0),
1726 NumberOrPercentage::Number(1.0),
1727 ),
1728 Scale::XYZ { x, y, z } => Transform::Scale3d(x.clone(), y.clone(), z.clone()),
1729 }
1730 }
1731}
1732
1733#[derive(Default)]
1734pub(crate) struct TransformHandler {
1735 transform: Option<(TransformList, VendorPrefix)>,
1736 translate: Option<Translate>,
1737 rotate: Option<Rotate>,
1738 scale: Option<Scale>,
1739 has_any: bool,
1740}
1741
1742impl<'i> PropertyHandler<'i> for TransformHandler {
1743 fn handle_property(
1744 &mut self,
1745 property: &Property<'i>,
1746 dest: &mut DeclarationList<'i>,
1747 context: &mut PropertyHandlerContext<'i, '_>,
1748 ) -> bool {
1749 use Property::*;
1750
1751 macro_rules! individual_property {
1752 ($prop: ident, $val: ident) => {{
1753 self.$prop = Some($val.clone());
1756 self.has_any = true;
1757 }};
1758 }
1759
1760 match property {
1761 Transform(val, vp) => {
1762 if let Some((cur, prefixes)) = &self.transform {
1765 if cur != val && !prefixes.contains(*vp) {
1766 self.flush(dest, context);
1767 }
1768 }
1769
1770 if let Some((transform, prefixes)) = &mut self.transform {
1772 *transform = val.clone();
1773 *prefixes |= *vp;
1774 } else {
1775 self.transform = Some((val.clone(), *vp));
1776 self.has_any = true;
1777 }
1778 }
1779 Translate(val) => individual_property!(translate, val),
1780 Rotate(val) => individual_property!(rotate, val),
1781 Scale(val) => individual_property!(scale, val),
1782 Unparsed(val)
1783 if matches!(
1784 val.property_id,
1785 PropertyId::Transform(_) | PropertyId::Translate | PropertyId::Rotate | PropertyId::Scale
1786 ) =>
1787 {
1788 self.flush(dest, context);
1789 let prop = if matches!(val.property_id, PropertyId::Transform(_)) {
1790 Property::Unparsed(val.get_prefixed(context.targets, Feature::Transform))
1791 } else {
1792 property.clone()
1793 };
1794 dest.push(prop)
1795 }
1796 _ => return false,
1797 }
1798
1799 true
1800 }
1801
1802 fn finalize(&mut self, dest: &mut DeclarationList<'i>, context: &mut PropertyHandlerContext<'i, '_>) {
1803 self.flush(dest, context);
1804 }
1805}
1806
1807impl TransformHandler {
1808 fn flush<'i>(&mut self, dest: &mut DeclarationList<'i>, context: &mut PropertyHandlerContext<'i, '_>) {
1809 if !self.has_any {
1810 return;
1811 }
1812
1813 self.has_any = false;
1814
1815 let transform = std::mem::take(&mut self.transform);
1816 let translate = std::mem::take(&mut self.translate);
1817 let rotate = std::mem::take(&mut self.rotate);
1818 let scale = std::mem::take(&mut self.scale);
1819
1820 if let Some((transform, prefix)) = transform {
1821 let prefix = context.targets.prefixes(prefix, Feature::Transform);
1822 dest.push(Property::Transform(transform, prefix))
1823 }
1824
1825 if let Some(translate) = translate {
1826 dest.push(Property::Translate(translate))
1827 }
1828
1829 if let Some(rotate) = rotate {
1830 dest.push(Property::Rotate(rotate))
1831 }
1832
1833 if let Some(scale) = scale {
1834 dest.push(Property::Scale(scale))
1835 }
1836 }
1837}