Updated euclid to version 0.6.5

And updated existing usages of Matrix4 to use Matrix4D<T>

components/compositing/compositor.rs

@@ -14,7 +14,7 @@ use euclid::point::TypedPoint2D;
 use euclid::rect::TypedRect;
 use euclid::scale_factor::ScaleFactor;
 use euclid::size::TypedSize2D;
-use euclid::{Matrix4, Point2D, Rect, Size2D};
+use euclid::{Matrix4D, Point2D, Rect, Size2D};
 use gfx::paint_thread::{ChromeToPaintMsg, PaintRequest};
 use gfx_traits::{color, Epoch, FrameTreeId, LayerId, LayerKind, LayerProperties, ScrollPolicy};
 use gleam::gl;
@@ -826,8 +826,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             rect: Rect::zero(),
             background_color: color::transparent(),
             scroll_policy: ScrollPolicy::Scrollable,
-            transform: Matrix4::identity(),
-            perspective: Matrix4::identity(),
+            transform: Matrix4D::identity(),
+            perspective: Matrix4D::identity(),
             subpage_pipeline_id: None,
             establishes_3d_context: true,
             scrolls_overflow_area: false,
@@ -1029,8 +1029,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             rect: Rect::new(Point2D::zero(), layer_properties.rect.size),
             background_color: layer_properties.background_color,
             scroll_policy: ScrollPolicy::Scrollable,
-            transform: Matrix4::identity(),
-            perspective: Matrix4::identity(),
+            transform: Matrix4D::identity(),
+            perspective: Matrix4D::identity(),
             subpage_pipeline_id: Some(subpage_pipeline_id),
             establishes_3d_context: true,
             scrolls_overflow_area: true,
@@ -1854,8 +1854,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         }
 
         if let Some(ref root_layer) = self.scene.root {
-            root_layer.update_transform_state(&Matrix4::identity(),
-                                              &Matrix4::identity(),
+            root_layer.update_transform_state(&Matrix4D::identity(),
+                                              &Matrix4D::identity(),
                                               &Point2D::zero());
         }
 

components/gfx/display_list/mod.rs

@@ -20,7 +20,7 @@ use azure::azure_hl::Color;
 use euclid::approxeq::ApproxEq;
 use euclid::num::Zero;
 use euclid::rect::TypedRect;
-use euclid::{Matrix2D, Matrix4, Point2D, Rect, SideOffsets2D, Size2D};
+use euclid::{Matrix2D, Matrix4D, Point2D, Rect, SideOffsets2D, Size2D};
 use fnv::FnvHasher;
 use gfx_traits::{LayerId, ScrollPolicy};
 use heapsize::HeapSizeOf;
@@ -346,7 +346,7 @@ impl DisplayList {
     /// Draws a single DisplayItem into the given PaintContext.
     pub fn draw_item_at_index_into_context(&self,
                                            paint_context: &mut PaintContext,
-                                           transform: &Matrix4,
+                                           transform: &Matrix4D<f32>,
                                            index: usize) {
         let old_transform = paint_context.draw_target.get_transform();
         paint_context.draw_target.set_transform(
@@ -386,7 +386,7 @@ impl DisplayList {
     /// Draws the DisplayList in order.
     pub fn draw_into_context<'a>(&self,
                                  paint_context: &mut PaintContext,
-                                 transform: &Matrix4,
+                                 transform: &Matrix4D<f32>,
                                  stacking_context_id: StackingContextId,
                                  start: usize,
                                  end: usize) {
@@ -403,7 +403,7 @@ impl DisplayList {
                                           stacking_context: &StackingContext,
                                           traversal: &mut DisplayListTraversal<'a>,
                                           paint_context: &mut PaintContext,
-                                          transform: &Matrix4,
+                                          transform: &Matrix4D<f32>,
                                           tile_rect: Option<Rect<Au>>) {
         for child in stacking_context.children.iter() {
             while let Some(item) = traversal.advance(stacking_context) {
@@ -431,7 +431,7 @@ impl DisplayList {
                                  stacking_context: &StackingContext,
                                  traversal: &mut DisplayListTraversal<'a>,
                                  paint_context: &mut PaintContext,
-                                 transform: &Matrix4) {
+                                 transform: &Matrix4D<f32>) {
 
         if stacking_context.context_type != StackingContextType::Real {
             self.draw_stacking_context_contents(stacking_context,
@@ -511,7 +511,7 @@ impl DisplayList {
     }
 }
 
-fn transformed_tile_rect(tile_rect: TypedRect<ScreenPx, usize>, transform: &Matrix4) -> Rect<Au> {
+fn transformed_tile_rect(tile_rect: TypedRect<ScreenPx, usize>, transform: &Matrix4D<f32>) -> Rect<Au> {
     // Invert the current transform, then use this to back transform
     // the tile rect (placed at the origin) into the space of this
     // stacking context.
@@ -568,10 +568,10 @@ pub struct StackingContext {
     pub blend_mode: mix_blend_mode::T,
 
     /// A transform to be applied to this stacking context.
-    pub transform: Matrix4,
+    pub transform: Matrix4D<f32>,
 
     /// The perspective matrix to be applied to children.
-    pub perspective: Matrix4,
+    pub perspective: Matrix4D<f32>,
 
     /// Whether this stacking context creates a new 3d rendering context.
     pub establishes_3d_context: bool,
@@ -596,8 +596,8 @@ impl StackingContext {
                z_index: i32,
                filters: filter::T,
                blend_mode: mix_blend_mode::T,
-               transform: Matrix4,
-               perspective: Matrix4,
+               transform: Matrix4D<f32>,
+               perspective: Matrix4D<f32>,
                establishes_3d_context: bool,
                scrolls_overflow_area: bool,
                layer_info: Option<LayerInfo>)
@@ -671,9 +671,9 @@ impl StackingContext {
         let origin_x = self.bounds.origin.x.to_f32_px();
         let origin_y = self.bounds.origin.y.to_f32_px();
 
-        let transform = Matrix4::identity().translate(origin_x,
-                                                      origin_y,
-                                                      0.0)
+        let transform = Matrix4D::identity().translate(origin_x,
+                                                       origin_y,
+                                                       0.0)
                                            .mul(&self.transform);
         let transform_2d = Matrix2D::new(transform.m11, transform.m12,
                                          transform.m21, transform.m22,

components/gfx/paint_thread.rs

@@ -9,7 +9,7 @@ use azure::AzFloat;
 use azure::azure_hl::{BackendType, Color, DrawTarget, SurfaceFormat};
 use display_list::{DisplayItem, DisplayList, DisplayListEntry, DisplayListTraversal};
 use display_list::{LayerInfo, StackingContext, StackingContextId, StackingContextType};
-use euclid::Matrix4;
+use euclid::Matrix4D;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use euclid::size::Size2D;
@@ -67,8 +67,8 @@ impl PaintLayer {
     fn new_from_stacking_context(layer_info: &LayerInfo,
                                  stacking_context: &StackingContext,
                                  parent_origin: &Point2D<Au>,
-                                 transform: &Matrix4,
-                                 perspective: &Matrix4,
+                                 transform: &Matrix4D<f32>,
+                                 perspective: &Matrix4D<f32>,
                                  parent_id: Option<LayerId>)
                                  -> PaintLayer {
         let bounds = Rect::new(stacking_context.bounds.origin + stacking_context.overflow.origin,
@@ -108,8 +108,8 @@ impl PaintLayer {
     fn new_for_display_item(layer_info: &LayerInfo,
                             item_bounds: &Rect<Au>,
                             parent_origin: &Point2D<Au>,
-                            transform: &Matrix4,
-                            perspective: &Matrix4,
+                            transform: &Matrix4D<f32>,
+                            perspective: &Matrix4D<f32>,
                             parent_id: Option<LayerId>,
                             stacking_context_id: StackingContextId,
                             item_index: usize)
@@ -179,8 +179,8 @@ impl LayerCreator {
         layer_creator.create_layers_for_stacking_context(&display_list.root_stacking_context,
                                                          &mut traversal,
                                                          &Point2D::zero(),
-                                                         &Matrix4::identity(),
-                                                         &Matrix4::identity());
+                                                         &Matrix4D::identity(),
+                                                         &Matrix4D::identity());
         layer_creator.layers
     }
 
@@ -204,8 +204,8 @@ impl LayerCreator {
                                               stacking_context: &StackingContext,
                                               traversal: &mut DisplayListTraversal<'a>,
                                               parent_origin: &Point2D<Au>,
-                                              transform: &Matrix4,
-                                              perspective: &Matrix4) {
+                                              transform: &Matrix4D<f32>,
+                                              perspective: &Matrix4D<f32>) {
         if let Some(ref layer_info) = stacking_context.layer_info {
             self.finalize_current_layer();
             let new_layer = PaintLayer::new_from_stacking_context(
@@ -227,8 +227,8 @@ impl LayerCreator {
             self.process_stacking_context_items(stacking_context,
                                                 traversal,
                                                 &-stacking_context.overflow.origin,
-                                                &Matrix4::identity(),
-                                                &Matrix4::identity());
+                                                &Matrix4D::identity(),
+                                                &Matrix4D::identity());
             self.finalize_current_layer();
             self.layer_details_stack.pop();
             return;
@@ -254,8 +254,8 @@ impl LayerCreator {
                                           stacking_context: &StackingContext,
                                           traversal: &mut DisplayListTraversal<'a>,
                                           parent_origin: &Point2D<Au>,
-                                          transform: &Matrix4,
-                                          perspective: &Matrix4) {
+                                          transform: &Matrix4D<f32>,
+                                          perspective: &Matrix4D<f32>) {
         for kid in stacking_context.children.iter() {
             while let Some(item) = traversal.advance(stacking_context) {
                 self.create_layers_for_item(item,
@@ -282,8 +282,8 @@ impl LayerCreator {
     fn create_layers_for_item<'a>(&mut self,
                                   item: &DisplayListEntry,
                                   parent_origin: &Point2D<Au>,
-                                  transform: &Matrix4,
-                                  perspective: &Matrix4) {
+                                  transform: &Matrix4D<f32>,
+                                  perspective: &Matrix4D<f32>) {
         if let DisplayItem::LayeredItemClass(ref layered_item) = item.item {
             // We need to finalize the last layer here before incrementing the entry
             // index, otherwise this item will be placed into the parent layer.
@@ -761,7 +761,7 @@ impl WorkerThread {
             };
 
             // Apply the translation to paint the tile we want.
-            let matrix = Matrix4::identity();
+            let matrix = Matrix4D::identity();
             let matrix = matrix.scale(scale as AzFloat, scale as AzFloat, 1.0);
             let tile_bounds = tile.page_rect.translate(&paint_layer.display_list_origin);
             let matrix = matrix.translate(-tile_bounds.origin.x as AzFloat,

components/gfx_traits/Cargo.toml

@@ -26,7 +26,7 @@ path = "../plugins"
 path = "../util"
 
 [dependencies]
-euclid = {version = "0.6.4", features = ["plugins"]}
+euclid = {version = "0.6.5", features = ["plugins"]}
 heapsize = "0.3.0"
 heapsize_plugin = "0.1.2"
 serde = "0.7"

components/gfx_traits/lib.rs

@@ -23,7 +23,7 @@ mod paint_listener;
 
 pub use paint_listener::PaintListener;
 use azure::azure_hl::Color;
-use euclid::matrix::Matrix4;
+use euclid::Matrix4D;
 use euclid::rect::Rect;
 use msg::constellation_msg::{Failure, PipelineId};
 use std::fmt::{self, Debug, Formatter};
@@ -132,9 +132,9 @@ pub struct LayerProperties {
     /// The scrolling policy of this layer.
     pub scroll_policy: ScrollPolicy,
     /// The transform for this layer
-    pub transform: Matrix4,
+    pub transform: Matrix4D<f32>,
     /// The perspective transform for this layer
-    pub perspective: Matrix4,
+    pub perspective: Matrix4D<f32>,
     /// The subpage that this layer represents. If this is `Some`, this layer represents an
     /// iframe.
     pub subpage_pipeline_id: Option<PipelineId>,

components/layout/display_list_builder.rs

@@ -16,7 +16,7 @@ use block::{BlockFlow, BlockStackingContextType};
 use canvas_traits::{CanvasMsg, CanvasPixelData, CanvasData, FromLayoutMsg};
 use context::LayoutContext;
 use euclid::num::Zero;
-use euclid::{Matrix4, Point2D, Point3D, Rect, SideOffsets2D, Size2D};
+use euclid::{Matrix4D, Point2D, Point3D, Rect, SideOffsets2D, Size2D};
 use flex::FlexFlow;
 use flow::{BaseFlow, Flow, IS_ABSOLUTELY_POSITIONED};
 use flow_ref;
@@ -112,12 +112,12 @@ const INSERTION_POINT_LOGICAL_WIDTH: Au = Au(1 * AU_PER_PX);
 // and behaves as it does in other browsers.
 // See https://lists.w3.org/Archives/Public/www-style/2016Jan/0020.html for more details.
 #[inline]
-fn create_perspective_matrix(d: Au) -> Matrix4 {
+fn create_perspective_matrix(d: Au) -> Matrix4D<f32> {
     let d = d.to_f32_px();
     if d <= 0.0 {
-        Matrix4::identity()
+        Matrix4D::identity()
     } else {
-        Matrix4::create_perspective(d)
+        Matrix4D::create_perspective(d)
     }
 }
 
@@ -1324,7 +1324,7 @@ impl FragmentDisplayListBuilding for Fragment {
             }
         };
 
-        let mut transform = Matrix4::identity();
+        let mut transform = Matrix4D::identity();
         if let Some(ref operations) = self.style().get_effects().transform.0 {
             let transform_origin = self.style().get_effects().transform_origin;
             let transform_origin =
@@ -1334,36 +1334,36 @@ impl FragmentDisplayListBuilding for Fragment {
                                               border_box.size.height).to_f32_px(),
                              transform_origin.depth.to_f32_px());
 
-            let pre_transform = Matrix4::create_translation(transform_origin.x,
-                                                            transform_origin.y,
-                                                            transform_origin.z);
-            let post_transform = Matrix4::create_translation(-transform_origin.x,
-                                                             -transform_origin.y,
-                                                             -transform_origin.z);
+            let pre_transform = Matrix4D::create_translation(transform_origin.x,
+                                                             transform_origin.y,
+                                                             transform_origin.z);
+            let post_transform = Matrix4D::create_translation(-transform_origin.x,
+                                                              -transform_origin.y,
+                                                              -transform_origin.z);
 
             for operation in operations {
                 let matrix = match *operation {
                     transform::ComputedOperation::Rotate(ax, ay, az, theta) => {
                         let theta = 2.0f32 * f32::consts::PI - theta.radians();
-                        Matrix4::create_rotation(ax, ay, az, theta)
+                        Matrix4D::create_rotation(ax, ay, az, theta)
                     }
                     transform::ComputedOperation::Perspective(d) => {
                         create_perspective_matrix(d)
                     }
                     transform::ComputedOperation::Scale(sx, sy, sz) => {
-                        Matrix4::create_scale(sx, sy, sz)
+                        Matrix4D::create_scale(sx, sy, sz)
                     }
                     transform::ComputedOperation::Translate(tx, ty, tz) => {
                         let tx = model::specified(tx, border_box.size.width).to_f32_px();
                         let ty = model::specified(ty, border_box.size.height).to_f32_px();
                         let tz = tz.to_f32_px();
-                        Matrix4::create_translation(tx, ty, tz)
+                        Matrix4D::create_translation(tx, ty, tz)
                     }
                     transform::ComputedOperation::Matrix(m) => {
                         m.to_gfx_matrix()
                     }
                     transform::ComputedOperation::Skew(theta_x, theta_y) => {
-                        Matrix4::create_skew(theta_x.radians(), theta_y.radians())
+                        Matrix4D::create_skew(theta_x.radians(), theta_y.radians())
                     }
                 };
 
@@ -1382,19 +1382,19 @@ impl FragmentDisplayListBuilding for Fragment {
                                  model::specified(perspective_origin.vertical,
                                                   border_box.size.height).to_f32_px());
 
-                let pre_transform = Matrix4::create_translation(perspective_origin.x,
-                                                                perspective_origin.y,
-                                                                0.0);
-                let post_transform = Matrix4::create_translation(-perspective_origin.x,
-                                                                 -perspective_origin.y,
+                let pre_transform = Matrix4D::create_translation(perspective_origin.x,
+                                                                 perspective_origin.y,
                                                                  0.0);
+                let post_transform = Matrix4D::create_translation(-perspective_origin.x,
+                                                                  -perspective_origin.y,
+                                                                  0.0);
 
                 let perspective_matrix = create_perspective_matrix(d);
 
                 pre_transform.mul(&perspective_matrix).mul(&post_transform)
             }
             LengthOrNone::None => {
-                Matrix4::identity()
+                Matrix4D::identity()
             }
         };
 

components/layout/layout_thread.rs

@@ -13,7 +13,7 @@ use azure::azure::AzColor;
 use construct::ConstructionResult;
 use context::{LayoutContext, SharedLayoutContext, heap_size_of_local_context};
 use display_list_builder::ToGfxColor;
-use euclid::Matrix4;
+use euclid::Matrix4D;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use euclid::scale_factor::ScaleFactor;
@@ -890,8 +890,8 @@ impl LayoutThread {
                                          0,
                                          filter::T::new(Vec::new()),
                                          mix_blend_mode::T::normal,
-                                         Matrix4::identity(),
-                                         Matrix4::identity(),
+                                         Matrix4D::identity(),
+                                         Matrix4D::identity(),
                                          true,
                                          false,
                                          None);