Rename `Transform2DF` to `Transform2F` and `Transform3DF` to `Transform4F`

c/src/lib.rs

@@ -19,8 +19,8 @@ use pathfinder_content::color::{ColorF, ColorU};
 use pathfinder_content::outline::ArcDirection;
 use pathfinder_content::stroke::LineCap;
 use pathfinder_geometry::rect::{RectF, RectI};
-use pathfinder_geometry::transform2d::{Matrix2x2F, Transform2DF};
+use pathfinder_geometry::transform2d::{Matrix2x2F, Transform2F};
-use pathfinder_geometry::transform3d::{Perspective, Transform3DF};
+use pathfinder_geometry::transform3d::{Perspective, Transform4F};
 use pathfinder_geometry::vector::{Vector2F, Vector2I};
 use pathfinder_gl::{GLDevice, GLVersion};
 use pathfinder_gpu::resources::{FilesystemResourceLoader, ResourceLoader};
@@ -135,13 +135,13 @@ pub struct PFMatrix2x2F {
 }
 /// Row-major order.
 #[repr(C)]
-pub struct PFTransform2DF {
+pub struct PFTransform2F {
     pub matrix: PFMatrix2x2F,
     pub vector: PFVector2F,
 }
 /// Row-major order.
 #[repr(C)]
-pub struct PFTransform3DF {
+pub struct PFTransform4F {
     pub m00: f32, pub m01: f32, pub m02: f32, pub m03: f32,
     pub m10: f32, pub m11: f32, pub m12: f32, pub m13: f32,
     pub m20: f32, pub m21: f32, pub m22: f32, pub m23: f32,
@@ -149,7 +149,7 @@ pub struct PFTransform3DF {
 }
 #[repr(C)]
 pub struct PFPerspective {
-    pub transform: PFTransform3DF,
+    pub transform: PFTransform4F,
     pub window_size: PFVector2I,
 }
 
@@ -610,7 +610,7 @@ pub unsafe extern "C" fn PFMetalDevicePresentDrawable(device: PFMetalDeviceRef)
 // `renderer`
 
 #[no_mangle]
-pub unsafe extern "C" fn PFRenderTransformCreate2D(transform: *const PFTransform2DF)
+pub unsafe extern "C" fn PFRenderTransformCreate2D(transform: *const PFTransform2F)
                                                    -> PFRenderTransformRef {
     Box::into_raw(Box::new(RenderTransform::Transform2D((*transform).to_rust())))
 }
@@ -743,17 +743,17 @@ impl PFMatrix2x2F {
     }
 }
 
-impl PFTransform2DF {
+impl PFTransform2F {
     #[inline]
-    pub fn to_rust(&self) -> Transform2DF {
+    pub fn to_rust(&self) -> Transform2F {
-        Transform2DF { matrix: self.matrix.to_rust(), vector: self.vector.to_rust() }
+        Transform2F { matrix: self.matrix.to_rust(), vector: self.vector.to_rust() }
     }
 }
 
-impl PFTransform3DF {
+impl PFTransform4F {
     #[inline]
-    pub fn to_rust(&self) -> Transform3DF {
+    pub fn to_rust(&self) -> Transform4F {
-        Transform3DF::row_major(self.m00, self.m01, self.m02, self.m03,
+        Transform4F::row_major(self.m00, self.m01, self.m02, self.m03,
                                 self.m10, self.m11, self.m12, self.m13,
                                 self.m20, self.m21, self.m22, self.m23,
                                 self.m30, self.m31, self.m32, self.m33)

canvas/src/lib.rs

@@ -25,7 +25,7 @@ use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle};
 use pathfinder_geometry::line_segment::LineSegment2F;
 use pathfinder_geometry::vector::Vector2F;
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_renderer::paint::{Paint, PaintId};
 use pathfinder_renderer::scene::{PathObject, Scene};
 use pathfinder_text::{SceneExt, TextRenderMode};
@@ -115,7 +115,7 @@ impl CanvasRenderingContext2D {
             TextAlign::Center => position.set_x(position.x() - layout.width() * 0.5),
         }
 
-        let transform = Transform2DF::from_translation(position).post_mul(&self.current_state
+        let transform = Transform2F::from_translation(position).post_mul(&self.current_state
                                                                                .transform);
 
         // TODO(pcwalton): Report errors.
@@ -286,7 +286,7 @@ impl CanvasRenderingContext2D {
             let paint_id = self.scene.push_paint(&paint);
 
             let mut outline = outline.clone();
-            outline.transform(&Transform2DF::from_translation(self.current_state.shadow_offset));
+            outline.transform(&Transform2F::from_translation(self.current_state.shadow_offset));
             self.scene.push_path(PathObject::new(outline, paint_id, String::new()))
         }
 
@@ -296,18 +296,18 @@ impl CanvasRenderingContext2D {
     // Transformations
 
     #[inline]
-    pub fn current_transform(&self) -> Transform2DF {
+    pub fn current_transform(&self) -> Transform2F {
         self.current_state.transform
     }
 
     #[inline]
-    pub fn set_current_transform(&mut self, new_transform: &Transform2DF) {
+    pub fn set_current_transform(&mut self, new_transform: &Transform2F) {
         self.current_state.transform = *new_transform;
     }
 
     #[inline]
     pub fn reset_transform(&mut self) {
-        self.current_state.transform = Transform2DF::default();
+        self.current_state.transform = Transform2F::default();
     }
 
     // Compositing
@@ -339,7 +339,7 @@ impl CanvasRenderingContext2D {
 
 #[derive(Clone)]
 struct State {
-    transform: Transform2DF,
+    transform: Transform2F,
     font_collection: Arc<FontCollection>,
     font_size: f32,
     line_width: f32,
@@ -359,7 +359,7 @@ struct State {
 impl State {
     fn default(default_font_collection: Arc<FontCollection>) -> State {
         State {
-            transform: Transform2DF::default(),
+            transform: Transform2F::default(),
             font_collection: default_font_collection,
             font_size: DEFAULT_FONT_SIZE,
             line_width: 1.0,
@@ -442,8 +442,8 @@ impl Path2D {
                start_angle: f32,
                end_angle: f32,
                direction: ArcDirection) {
-        let mut transform = Transform2DF::from_scale(Vector2F::splat(radius));
+        let mut transform = Transform2F::from_scale(Vector2F::splat(radius));
-        transform = transform.post_mul(&Transform2DF::from_translation(center));
+        transform = transform.post_mul(&Transform2F::from_translation(center));
         self.current_contour.push_arc(&transform, start_angle, end_angle, direction);
     }
 
@@ -457,8 +457,8 @@ impl Path2D {
         let bisector = vu0 + vu1;
         let center = ctrl + bisector.scale(hypot / bisector.length());
 
-        let mut transform = Transform2DF::from_scale(Vector2F::splat(radius));
+        let mut transform = Transform2F::from_scale(Vector2F::splat(radius));
-        transform = transform.post_mul(&Transform2DF::from_translation(center));
+        transform = transform.post_mul(&Transform2F::from_translation(center));
 
         let chord = LineSegment2F::new(vu0.yx().scale_xy(Vector2F::new(-1.0, 1.0)),
                                       vu1.yx().scale_xy(Vector2F::new(1.0, -1.0)));
@@ -484,9 +484,9 @@ impl Path2D {
                    end_angle: f32) {
         self.flush_current_contour();
 
-        let mut transform = Transform2DF::from_rotation(rotation);
+        let mut transform = Transform2F::from_rotation(rotation);
-        transform = transform.post_mul(&Transform2DF::from_scale(axes));
+        transform = transform.post_mul(&Transform2F::from_scale(axes));
-        transform = transform.post_mul(&Transform2DF::from_translation(center));
+        transform = transform.post_mul(&Transform2F::from_translation(center));
         self.current_contour.push_arc(&transform, start_angle, end_angle, ArcDirection::CW);
 
         if end_angle - start_angle >= 2.0 * PI {

content/src/outline.rs

@@ -16,7 +16,7 @@ use crate::orientation::Orientation;
 use crate::segment::{Segment, SegmentFlags, SegmentKind};
 use pathfinder_geometry::line_segment::LineSegment2F;
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_geometry::transform3d::Perspective;
 use pathfinder_geometry::unit_vector::UnitVector;
 use pathfinder_geometry::vector::Vector2F;
@@ -134,7 +134,7 @@ impl Outline {
         self.contours.push(contour);
     }
 
-    pub fn transform(&mut self, transform: &Transform2DF) {
+    pub fn transform(&mut self, transform: &Transform2F) {
         if transform.is_identity() {
             return;
         }
@@ -353,7 +353,7 @@ impl Contour {
     }
 
     pub fn push_arc(&mut self,
-                    transform: &Transform2DF,
+                    transform: &Transform2F,
                     start_angle: f32,
                     end_angle: f32,
                     direction: ArcDirection) {
@@ -367,13 +367,13 @@ impl Contour {
     }
 
     pub fn push_arc_from_unit_chord(&mut self,
-                                    transform: &Transform2DF,
+                                    transform: &Transform2F,
                                     mut chord: LineSegment2F,
                                     direction: ArcDirection) {
-        let mut direction_transform = Transform2DF::default();
+        let mut direction_transform = Transform2F::default();
         if direction == ArcDirection::CCW {
             chord = chord.scale_xy(Vector2F::new(-1.0, 1.0));
-            direction_transform = Transform2DF::from_scale(Vector2F::new(-1.0, 1.0));
+            direction_transform = Transform2F::from_scale(Vector2F::new(-1.0, 1.0));
         }
 
         let (mut vector, end_vector) = (UnitVector(chord.from()), UnitVector(chord.to()));
@@ -392,7 +392,7 @@ impl Contour {
             }
 
             let half_sweep_vector = sweep_vector.halve_angle();
-            let rotation = Transform2DF::from_rotation_vector(half_sweep_vector.rotate_by(vector));
+            let rotation = Transform2F::from_rotation_vector(half_sweep_vector.rotate_by(vector));
             segment = segment.transform(&direction_transform.post_mul(&rotation)
                                                             .post_mul(&transform));
 
@@ -413,18 +413,18 @@ impl Contour {
         const EPSILON: f32 = 0.001;
     }
 
-    pub fn push_ellipse(&mut self, transform: &Transform2DF) {
+    pub fn push_ellipse(&mut self, transform: &Transform2F) {
         let segment = Segment::quarter_circle_arc();
         let mut rotation;
         self.push_segment(&segment.transform(transform),
                           PushSegmentFlags::UPDATE_BOUNDS | PushSegmentFlags::INCLUDE_FROM_POINT);
-        rotation = Transform2DF::from_rotation_vector(UnitVector(Vector2F::new( 0.0,  1.0)));
+        rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new( 0.0,  1.0)));
         self.push_segment(&segment.transform(&rotation.post_mul(&transform)),
                           PushSegmentFlags::UPDATE_BOUNDS);
-        rotation = Transform2DF::from_rotation_vector(UnitVector(Vector2F::new(-1.0,  0.0)));
+        rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new(-1.0,  0.0)));
         self.push_segment(&segment.transform(&rotation.post_mul(&transform)),
                           PushSegmentFlags::UPDATE_BOUNDS);
-        rotation = Transform2DF::from_rotation_vector(UnitVector(Vector2F::new( 0.0, -1.0)));
+        rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new( 0.0, -1.0)));
         self.push_segment(&segment.transform(&rotation.post_mul(&transform)),
                           PushSegmentFlags::UPDATE_BOUNDS);
     }
@@ -528,7 +528,7 @@ impl Contour {
         }
     }
 
-    pub fn transform(&mut self, transform: &Transform2DF) {
+    pub fn transform(&mut self, transform: &Transform2F) {
         if transform.is_identity() {
             return;
         }

content/src/segment.rs

@@ -11,7 +11,7 @@
 //! Line or curve segments, optimized with SIMD.
 
 use pathfinder_geometry::line_segment::LineSegment2F;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_geometry::util::{self, EPSILON};
 use pathfinder_geometry::vector::Vector2F;
 use pathfinder_simd::default::F32x4;
@@ -215,7 +215,7 @@ impl Segment {
     }
 
     #[inline]
-    pub fn transform(self, transform: &Transform2DF) -> Segment {
+    pub fn transform(self, transform: &Transform2F) -> Segment {
         Segment {
             baseline: transform.transform_line_segment(self.baseline),
             ctrl: transform.transform_line_segment(self.ctrl),

content/src/stroke.rs

@@ -14,7 +14,7 @@ use crate::outline::{ArcDirection, Contour, Outline, PushSegmentFlags};
 use crate::segment::Segment;
 use pathfinder_geometry::line_segment::LineSegment2F;
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_geometry::vector::Vector2F;
 use std::f32;
 
@@ -138,9 +138,9 @@ impl<'a> OutlineStrokeToFill<'a> {
             LineCap::Round => {
                 let scale = Vector2F::splat(width * 0.5);
                 let offset = gradient.yx().scale_xy(Vector2F::new(-1.0, 1.0));
-                let mut transform = Transform2DF::from_scale(scale);
+                let mut transform = Transform2F::from_scale(scale);
                 let translation = p1 + offset.scale(width * 0.5);
-                transform = transform.post_mul(&Transform2DF::from_translation(translation));
+                transform = transform.post_mul(&Transform2F::from_translation(translation));
                 let chord = LineSegment2F::new(-offset, offset);
                 contour.push_arc_from_unit_chord(&transform, chord, ArcDirection::CW);
             }
@@ -374,8 +374,8 @@ impl Contour {
             }
             LineJoin::Round => {
                 let scale = Vector2F::splat(distance.abs());
-                let mut transform = Transform2DF::from_scale(scale);
+                let mut transform = Transform2F::from_scale(scale);
-                transform = transform.post_mul(&Transform2DF::from_translation(join_point));
+                transform = transform.post_mul(&Transform2F::from_translation(join_point));
                 let chord_from = (prev_tangent.to() - join_point).normalize();
                 let chord_to = (next_tangent.to() - join_point).normalize();
                 let chord = LineSegment2F::new(chord_from, chord_to);

content/src/transform.rs

@@ -11,19 +11,19 @@
 //! Utilities for transforming paths.
 
 use crate::segment::Segment;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_geometry::transform3d::Perspective;
 
 /// Transforms a path with a SIMD 2D transform.
-pub struct Transform2DFPathIter<I>
+pub struct Transform2FPathIter<I>
 where
     I: Iterator<Item = Segment>,
 {
     iter: I,
-    transform: Transform2DF,
+    transform: Transform2F,
 }
 
-impl<I> Iterator for Transform2DFPathIter<I>
+impl<I> Iterator for Transform2FPathIter<I>
 where
     I: Iterator<Item = Segment>,
 {
@@ -47,13 +47,13 @@ where
     }
 }
 
-impl<I> Transform2DFPathIter<I>
+impl<I> Transform2FPathIter<I>
 where
     I: Iterator<Item = Segment>,
 {
     #[inline]
-    pub fn new(iter: I, transform: &Transform2DF) -> Transform2DFPathIter<I> {
+    pub fn new(iter: I, transform: &Transform2F) -> Transform2FPathIter<I> {
-        Transform2DFPathIter {
+        Transform2FPathIter {
             iter,
             transform: *transform,
         }

demo/common/src/camera.rs

@@ -16,8 +16,8 @@
 use crate::window::{OcularTransform, View};
 use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F};
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
-use pathfinder_geometry::transform3d::{Perspective, Transform3DF};
+use pathfinder_geometry::transform3d::{Perspective, Transform4F};
 use std::f32::consts::FRAC_PI_4;
 
 const NEAR_CLIP_PLANE: f32 = 0.01;
@@ -27,7 +27,7 @@ const FAR_CLIP_PLANE: f32 = 10.0;
 const DEFAULT_EYE_OFFSET: f32 = 0.025;
 
 pub enum Camera {
-    TwoD(Transform2DF),
+    TwoD(Transform2F),
     ThreeD {
         // The ocular transform used for rendering of the scene to the scene framebuffer. If we are
         // performing stereoscopic rendering, this is then reprojected according to the eye
@@ -56,7 +56,7 @@ impl Camera {
         let scale = i32::min(viewport_size.x(), viewport_size.y()) as f32
             * scale_factor_for_view_box(view_box);
         let origin = viewport_size.to_f32().scale(0.5) - view_box.size().scale(scale * 0.5);
-        Camera::TwoD(Transform2DF::from_scale(Vector2F::splat(scale)).post_translate(origin))
+        Camera::TwoD(Transform2F::from_scale(Vector2F::splat(scale)).post_translate(origin))
     }
 
     fn new_3d(mode: Mode, view_box: RectF, viewport_size: Vector2I) -> Camera {
@@ -65,7 +65,7 @@ impl Camera {
         let fov_y = FRAC_PI_4;
         let aspect = viewport_size.x() as f32 / viewport_size.y() as f32;
         let projection =
-            Transform3DF::from_perspective(fov_y, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
+            Transform4F::from_perspective(fov_y, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
         let perspective = Perspective::new(&projection, viewport_size);
 
         // Create a scene transform by moving the camera back from the center of the eyes so that
@@ -73,7 +73,7 @@ impl Camera {
         let z_offset = Vector4F::new(0.0, 0.0, -DEFAULT_EYE_OFFSET * projection.c0.x(), 1.0);
         let scene_transform = OcularTransform {
             perspective,
-            modelview_to_eye: Transform3DF::from_translation(z_offset),
+            modelview_to_eye: Transform4F::from_translation(z_offset),
         };
 
         // For now, initialize the eye transforms as copies of the scene transform.
@@ -88,7 +88,7 @@ impl Camera {
                 let this_eye_offset = Vector4F::new(this_eye_offset, 0.0, 0.0, 1.0);
                 OcularTransform {
                     perspective,
-                    modelview_to_eye: Transform3DF::from_translation(this_eye_offset),
+                    modelview_to_eye: Transform4F::from_translation(this_eye_offset),
                 }
             })
             .collect();
@@ -146,20 +146,20 @@ impl CameraTransform3D {
     pub fn offset(&mut self, vector: Vector4F) -> bool {
         let update = !vector.is_zero();
         if update {
-            let rotation = Transform3DF::from_rotation(-self.yaw, -self.pitch, 0.0);
+            let rotation = Transform4F::from_rotation(-self.yaw, -self.pitch, 0.0);
             self.position = self.position + rotation.transform_point(vector);
         }
         update
     }
 
-    pub fn to_transform(&self) -> Transform3DF {
+    pub fn to_transform(&self) -> Transform4F {
-        let mut transform = Transform3DF::from_rotation(self.yaw, self.pitch, 0.0);
+        let mut transform = Transform4F::from_rotation(self.yaw, self.pitch, 0.0);
-        transform *= Transform3DF::from_uniform_scale(2.0 * self.scale);
+        transform *= Transform4F::from_uniform_scale(2.0 * self.scale);
         transform *=
-            Transform3DF::from_translation(self.position * Vector4F::new(-1.0, -1.0, -1.0, 1.0));
+            Transform4F::from_translation(self.position * Vector4F::new(-1.0, -1.0, -1.0, 1.0));
 
         // Flip Y.
-        transform *= Transform3DF::from_scale(Vector4F::new(1.0, -1.0, 1.0, 1.0));
+        transform *= Transform4F::from_scale(Vector4F::new(1.0, -1.0, 1.0, 1.0));
 
         transform
     }

demo/common/src/lib.rs

@@ -25,8 +25,8 @@ use clap::{App, Arg};
 use pathfinder_content::color::ColorU;
 use pathfinder_export::{Export, FileFormat};
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
-use pathfinder_geometry::transform3d::Transform3DF;
+use pathfinder_geometry::transform3d::Transform4F;
 use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F};
 use pathfinder_gpu::resources::ResourceLoader;
 use pathfinder_gpu::Device;
@@ -368,7 +368,7 @@ impl<W> DemoApp<W> where W: Window {
                             scene_transform.perspective.transform.c0.x();
                         let z_offset = Vector4F::new(0.0, 0.0, z_offset, 1.0);
                         scene_transform.modelview_to_eye =
-                            Transform3DF::from_translation(z_offset) *
+                            Transform4F::from_translation(z_offset) *
                             scene_transform.modelview_to_eye;
                     }
                 }
@@ -627,7 +627,7 @@ impl<W> DemoApp<W> where W: Window {
             }
             UIAction::ZoomActualSize => {
                 if let Camera::TwoD(ref mut transform) = self.camera {
-                    *transform = Transform2DF::default();
+                    *transform = Transform2F::default();
                     self.dirty = true;
                 }
             }

demo/common/src/renderer.rs

@@ -18,7 +18,7 @@ use pathfinder_content::color::{ColorF, ColorU};
 use pathfinder_gpu::{ClearOps, DepthFunc, DepthState, Device, Primitive, RenderOptions};
 use pathfinder_gpu::{RenderState, RenderTarget, TextureData, TextureFormat, UniformData};
 use pathfinder_geometry::rect::RectI;
-use pathfinder_geometry::transform3d::Transform3DF;
+use pathfinder_geometry::transform3d::Transform4F;
 use pathfinder_geometry::vector::{Vector2I, Vector4F};
 use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
 use pathfinder_renderer::gpu::renderer::RenderMode;
@@ -165,7 +165,7 @@ impl<W> DemoApp<W> where W: Window {
 
         let mut quad_scale = self.scene_metadata.view_box.size().to_3d();
         quad_scale.set_z(1.0);
-        let quad_scale_transform = Transform3DF::from_scale(quad_scale);
+        let quad_scale_transform = Transform4F::from_scale(quad_scale);
 
         let scene_transform_matrix = scene_transform.perspective *
             scene_transform.modelview_to_eye *
@@ -213,11 +213,11 @@ impl<W> DemoApp<W> where W: Window {
         let mut offset = self.scene_metadata.view_box.lower_right().to_3d();
         offset.set_z(ground_scale);
         offset = offset * Vector4F::new(-0.5, 1.0, -0.5, 1.0);
-        let base_transform = perspective.transform * Transform3DF::from_translation(offset);
+        let base_transform = perspective.transform * Transform4F::from_translation(offset);
 
         // Fill ground.
         let transform = base_transform *    
-            Transform3DF::from_scale(Vector4F::new(ground_scale, 1.0, ground_scale, 1.0));
+            Transform4F::from_scale(Vector4F::new(ground_scale, 1.0, ground_scale, 1.0));
 
         // Don't clear the first scene after drawing it.
         let clear_color = if render_scene_index == 0 {

demo/common/src/window.rs

@@ -12,7 +12,7 @@
 
 use pathfinder_geometry::vector::Vector2I;
 use pathfinder_geometry::rect::RectI;
-use pathfinder_geometry::transform3d::{Perspective, Transform3DF};
+use pathfinder_geometry::transform3d::{Perspective, Transform4F};
 use pathfinder_gpu::resources::ResourceLoader;
 use rayon::ThreadPoolBuilder;
 use std::path::PathBuf;
@@ -109,7 +109,7 @@ pub struct OcularTransform {
     pub perspective: Perspective,
 
     // The view transform which converts from world coordinates to camera coordinates
-    pub modelview_to_eye: Transform3DF,
+    pub modelview_to_eye: Transform4F,
 }
 
 #[derive(Clone)]

demo/magicleap/src/display.rs

@@ -13,7 +13,7 @@ use std::io;
 use pathfinder_geometry::point::Point2DI32;
 use pathfinder_geometry::rect::RectI32;
 use pathfinder_geometry::transform3d::Perspective;
-use pathfinder_geometry::transform3d::Transform3DF32;
+use pathfinder_geometry::transform3d::Transform4F32;
 use pathfinder_gl::GLVersion;
 use pathfinder_gpu::resources::ResourceLoader;
 
@@ -36,7 +36,7 @@ pub trait DisplayCamera {
     type Error: DisplayError;
 
     fn bounds(&self) -> RectI32;
-    fn view(&self) -> Transform3DF32;
+    fn view(&self) -> Transform4F32;
     fn perspective(&self) -> Perspective;
 
     fn make_current(&mut self) -> Result<(), Self::Error>;

demo/magicleap/src/glwindow.rs

@@ -27,7 +27,7 @@ use crate::display::DisplayError;
 
 use pathfinder_geometry::point::Point2DI32;
 use pathfinder_geometry::rect::RectI32;
-use pathfinder_geometry::transform3d::Transform3DF32;
+use pathfinder_geometry::transform3d::Transform4F32;
 use pathfinder_geometry::transform3d::Perspective;
 use pathfinder_gl::GLVersion;
 use pathfinder_gpu::resources::FilesystemResourceLoader;
@@ -149,15 +149,15 @@ impl DisplayCamera for GlWindowCamera {
         // TODO: add eye offsets
         let bounds = self.bounds();
         let aspect = bounds.size().x() as f32 / bounds.size().y() as f32;
-        let transform = Transform3DF32::from_perspective(FRAC_PI_4, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
+        let transform = Transform4F32::from_perspective(FRAC_PI_4, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
         Perspective::new(&transform, bounds.size())
     }
 
-    fn view(&self) -> Transform3DF32 {
+    fn view(&self) -> Transform4F32 {
         let duration = Instant::now() - self.start;
         let rotation = duration.as_millis() as f32 / 1000.0;
-        Transform3DF32::from_rotation(rotation, 0.0, 0.0)
+        Transform4F32::from_rotation(rotation, 0.0, 0.0)
-            .pre_mul(&Transform3DF32::from_translation(0.0, 0.0, -CAMERA_DISTANCE))
+            .pre_mul(&Transform4F32::from_translation(0.0, 0.0, -CAMERA_DISTANCE))
     }
 }
 

demo/magicleap/src/immersive.rs

@@ -19,8 +19,8 @@ use pathfinder_geometry::point::Point2DI32;
 use pathfinder_geometry::point::Point2DF32;
 use pathfinder_geometry::point::Point3DF32;
 use pathfinder_geometry::rect::RectI32;
-use pathfinder_geometry::transform2d::Transform2DF32;
+use pathfinder_geometry::transform2d::Transform2F32;
-use pathfinder_geometry::transform3d::Transform3DF32;
+use pathfinder_geometry::transform3d::Transform4F32;
 use pathfinder_geometry::transform3d::Perspective;
 use pathfinder_gpu::Device;
 use pathfinder_simd::default::F32x4;
@@ -41,7 +41,7 @@ pub struct ImmersiveDemo<D> {
     renderer: Renderer<GLDevice>,
     scene_thread_proxy: SceneThreadProxy,
     svg_size: Point2DF32,
-    svg_to_world: Option<Transform3DF32>,
+    svg_to_world: Option<Transform4F32>,
 }
 
 static DEFAULT_SVG_VIRTUAL_PATH: &'static str = "svg/Ghostscript_Tiger.svg";
@@ -87,13 +87,13 @@ impl<D: Display> ImmersiveDemo<D> {
 
         let svg_size = self.svg_size;
         let svg_to_world = self.svg_to_world.get_or_insert_with(|| {
-	    let view: Transform3DF32 = cameras[0].view();
+	    let view: Transform4F32 = cameras[0].view();
             let svg_to_world_scale = f32::max(MAX_SVG_WIDTH / svg_size.x(), MAX_SVG_HEIGHT / svg_size.y());
 	    let svg_width = svg_size.x() * svg_to_world_scale;
 	    let svg_height = svg_size.y() * svg_to_world_scale;
-            Transform3DF32::from_uniform_scale(svg_to_world_scale)
+            Transform4F32::from_uniform_scale(svg_to_world_scale)
-                .pre_mul(&Transform3DF32::from_translation(-svg_width / 2.0, -svg_height / 2.0, -DEFAULT_SVG_DISTANCE))
+                .pre_mul(&Transform4F32::from_translation(-svg_width / 2.0, -svg_height / 2.0, -DEFAULT_SVG_DISTANCE))
-                .pre_mul(&Transform3DF32::from_scale(1.0, -1.0, 1.0))
+                .pre_mul(&Transform4F32::from_scale(1.0, -1.0, 1.0))
                 .pre_mul(&view.inverse())
 	});
 

demo/magicleap/src/lib.rs

@@ -32,7 +32,7 @@ use pathfinder_demo::window::SVGPath;
 use pathfinder_geometry::vector::Vector2F;
 use pathfinder_geometry::vector::Vector2I;
 use pathfinder_geometry::rect::RectI;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_content::color::ColorF;
 use pathfinder_gl::GLDevice;
 use pathfinder_gl::GLVersion;
@@ -216,9 +216,9 @@ pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *
 
         let scale = i32::min(viewport_size.x(), viewport_size.y()) as f32 /
             f32::max(svg.scene.bounds().size().x(), svg.scene.bounds().size().y());
-        let transform = Transform2DF::from_translation(svg.scene.bounds().size().scale(-0.5))
+        let transform = Transform2F::from_translation(svg.scene.bounds().size().scale(-0.5))
-            .post_mul(&Transform2DF::from_scale(Vector2F::splat(scale)))
+            .post_mul(&Transform2F::from_scale(Vector2F::splat(scale)))
-            .post_mul(&Transform2DF::from_translation(viewport_size.to_f32().scale(0.5)));
+            .post_mul(&Transform2F::from_translation(viewport_size.to_f32().scale(0.5)));
             
         let render_options = RenderOptions {
             transform: RenderTransform::Transform2D(transform),

demo/magicleap/src/magicleap.rs

@@ -53,7 +53,7 @@ use pathfinder_geometry::vector::Vector2F;
 use pathfinder_geometry::rect::RectF;
 use pathfinder_geometry::rect::RectI;
 use pathfinder_geometry::transform3d::Perspective;
-use pathfinder_geometry::transform3d::Transform3DF;
+use pathfinder_geometry::transform3d::Transform4F;
 use pathfinder_geometry::util;
 use pathfinder_gl::GLVersion;
 use pathfinder_gpu::resources::FilesystemResourceLoader;
@@ -77,7 +77,7 @@ pub struct MagicLeapWindow {
     graphics_client: MLHandle,
     size: Vector2I,
     virtual_camera_array: MLGraphicsVirtualCameraInfoArray,
-    initial_camera_transform: Option<Transform3DF>,
+    initial_camera_transform: Option<Transform4F>,
     frame_handle: MLHandle,
     resource_loader: FilesystemResourceLoader,
     pose_event: Option<Vec<OcularTransform>>,
@@ -234,21 +234,21 @@ impl MagicLeapWindow {
             }
             let virtual_camera_array = &self.virtual_camera_array;
             let initial_camera = self.initial_camera_transform.get_or_insert_with(|| {
-                let initial_offset = Transform3DF::from_translation(0.0, 0.0, 1.0);
+                let initial_offset = Transform4F::from_translation(0.0, 0.0, 1.0);
 	        let mut camera = virtual_camera_array.virtual_cameras[0].transform;
 		for i in 1..virtual_camera_array.num_virtual_cameras {
 		    let next = virtual_camera_array.virtual_cameras[i as usize].transform;
 		    camera = camera.lerp(next, 1.0 / (i as f32 + 1.0));
 		}
-		Transform3DF::from(camera).post_mul(&initial_offset)
+		Transform4F::from(camera).post_mul(&initial_offset)
             });
             let camera_transforms = (0..virtual_camera_array.num_virtual_cameras)
                 .map(|i| {
 		    let camera = &virtual_camera_array.virtual_cameras[i as usize];
-                    let projection = Transform3DF::from(camera.projection);
+                    let projection = Transform4F::from(camera.projection);
                     let size = RectI::from(virtual_camera_array.viewport).size();
                     let perspective = Perspective::new(&projection, size);
-                    let modelview_to_eye = Transform3DF::from(camera.transform).inverse().post_mul(initial_camera);
+                    let modelview_to_eye = Transform4F::from(camera.transform).inverse().post_mul(initial_camera);
                     OcularTransform { perspective, modelview_to_eye }
                 })
                 .collect();
@@ -355,16 +355,16 @@ impl MLTransform {
 
 // Impl pathfinder traits for c-api types
 
-impl From<MLTransform> for Transform3DF {
+impl From<MLTransform> for Transform4F {
     fn from(mat: MLTransform) -> Self {
-        Transform3DF::from(mat.rotation)
+        Transform4F::from(mat.rotation)
-           .pre_mul(&Transform3DF::from(mat.position))
+           .pre_mul(&Transform4F::from(mat.position))
     }
 }
 
-impl From<MLVec3f> for Transform3DF {
+impl From<MLVec3f> for Transform4F {
     fn from(v: MLVec3f) -> Self {
-        Transform3DF::from_translation(v.x, v.y, v.z)
+        Transform4F::from_translation(v.x, v.y, v.z)
     }
 }
 
@@ -380,16 +380,16 @@ impl From<MLRectf> for RectI {
     }
 }
 
-impl From<MLQuaternionf> for Transform3DF {
+impl From<MLQuaternionf> for Transform4F {
     fn from(q: MLQuaternionf) -> Self {
-        Transform3DF::from_rotation_quaternion(F32x4::new(q.x, q.y, q.z, q.w))
+        Transform4F::from_rotation_quaternion(F32x4::new(q.x, q.y, q.z, q.w))
     }
 }
 
-impl From<MLMat4f> for Transform3DF {
+impl From<MLMat4f> for Transform4F {
     fn from(mat: MLMat4f) -> Self {
         let a = mat.matrix_colmajor;
-        Transform3DF::row_major(a[0], a[4], a[8],  a[12],
+        Transform4F::row_major(a[0], a[4], a[8],  a[12],
                                   a[1], a[5], a[9],  a[13],
                                   a[2], a[6], a[10], a[14],
                                   a[3], a[7], a[11], a[15])

examples/swf_basic/src/main.rs

@@ -24,7 +24,7 @@ use pathfinder_renderer::scene::Scene;
 use pathfinder_swf::{draw_paths_into_scene, process_swf_tags};
 use std::env;
 use std::fs::read;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 
 fn main() {
     let resource_loader = FilesystemResourceLoader::locate();
@@ -118,7 +118,7 @@ fn main() {
     // Render the canvas to screen.
     let scene = SceneProxy::from_scene(scene, RayonExecutor);
     let mut build_options = BuildOptions::default();
-    let scale_transform = Transform2DF::from_scale(
+    let scale_transform = Transform2F::from_scale(
         Vector2F::new(device_pixel_ratio, device_pixel_ratio)
     );
     build_options.transform = RenderTransform::Transform2D(scale_transform);

geometry/src/transform2d.rs

@@ -13,7 +13,7 @@
 use crate::line_segment::LineSegment2F;
 use crate::vector::Vector2F;
 use crate::rect::RectF;
-use crate::transform3d::Transform3DF;
+use crate::transform3d::Transform4F;
 use crate::unit_vector::UnitVector;
 use pathfinder_simd::default::F32x4;
 use std::ops::Sub;
@@ -114,47 +114,47 @@ impl Sub<Matrix2x2F> for Matrix2x2F {
 
 /// An affine transform, optimized with SIMD.
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Transform2DF {
+pub struct Transform2F {
     // Row-major order.
     pub matrix: Matrix2x2F,
     pub vector: Vector2F,
 }
 
-impl Default for Transform2DF {
+impl Default for Transform2F {
     #[inline]
-    fn default() -> Transform2DF {
+    fn default() -> Transform2F {
         Self::from_scale(Vector2F::splat(1.0))
     }
 }
 
-impl Transform2DF {
+impl Transform2F {
     #[inline]
-    pub fn from_scale(scale: Vector2F) -> Transform2DF {
+    pub fn from_scale(scale: Vector2F) -> Transform2F {
-        Transform2DF {
+        Transform2F {
             matrix: Matrix2x2F::from_scale(scale),
             vector: Vector2F::default(),
         }
     }
 
     #[inline]
-    pub fn from_rotation(theta: f32) -> Transform2DF {
+    pub fn from_rotation(theta: f32) -> Transform2F {
-        Transform2DF {
+        Transform2F {
             matrix: Matrix2x2F::from_rotation(theta),
             vector: Vector2F::default(),
         }
     }
 
     #[inline]
-    pub fn from_rotation_vector(vector: UnitVector) -> Transform2DF {
+    pub fn from_rotation_vector(vector: UnitVector) -> Transform2F {
-        Transform2DF {
+        Transform2F {
             matrix: Matrix2x2F::from_rotation_vector(vector),
             vector: Vector2F::default(),
         }
     }
 
     #[inline]
-    pub fn from_translation(vector: Vector2F) -> Transform2DF {
+    pub fn from_translation(vector: Vector2F) -> Transform2F {
-        Transform2DF { matrix: Matrix2x2F::default(), vector }
+        Transform2F { matrix: Matrix2x2F::default(), vector }
     }
 
     #[inline]
@@ -162,15 +162,15 @@ impl Transform2DF {
         scale: Vector2F,
         theta: f32,
         translation: Vector2F,
-    ) -> Transform2DF {
+    ) -> Transform2F {
-        let rotation = Transform2DF::from_rotation(theta);
+        let rotation = Transform2F::from_rotation(theta);
-        let translation = Transform2DF::from_translation(translation);
+        let translation = Transform2F::from_translation(translation);
-        Transform2DF::from_scale(scale).post_mul(&rotation).post_mul(&translation)
+        Transform2F::from_scale(scale).post_mul(&rotation).post_mul(&translation)
     }
 
     #[inline]
-    pub fn row_major(m11: f32, m12: f32, m21: f32, m22: f32, m31: f32, m32: f32) -> Transform2DF {
+    pub fn row_major(m11: f32, m12: f32, m21: f32, m22: f32, m31: f32, m32: f32) -> Transform2F {
-        Transform2DF {
+        Transform2F {
             matrix: Matrix2x2F::row_major(m11, m12, m21, m22),
             vector: Vector2F::new(m31, m32),
         }
@@ -199,21 +199,21 @@ impl Transform2DF {
     }
 
     #[inline]
-    pub fn post_mul(&self, other: &Transform2DF) -> Transform2DF {
+    pub fn post_mul(&self, other: &Transform2F) -> Transform2F {
         let matrix = self.matrix.post_mul(&other.matrix);
         let vector = other.transform_point(self.vector);
-        Transform2DF { matrix, vector }
+        Transform2F { matrix, vector }
     }
 
     #[inline]
-    pub fn pre_mul(&self, other: &Transform2DF) -> Transform2DF {
+    pub fn pre_mul(&self, other: &Transform2F) -> Transform2F {
         other.post_mul(self)
     }
 
     // TODO(pcwalton): Optimize better with SIMD.
     #[inline]
-    pub fn to_3d(&self) -> Transform3DF {
+    pub fn to_3d(&self) -> Transform4F {
-        Transform3DF::row_major(
+        Transform4F::row_major(
             self.matrix.0[0],
             self.matrix.0[1],
             0.0,
@@ -235,7 +235,7 @@ impl Transform2DF {
 
     #[inline]
     pub fn is_identity(&self) -> bool {
-        *self == Transform2DF::default()
+        *self == Transform2F::default()
     }
 
     #[inline]
@@ -256,18 +256,18 @@ impl Transform2DF {
     }
 
     #[inline]
-    pub fn post_translate(&self, vector: Vector2F) -> Transform2DF {
+    pub fn post_translate(&self, vector: Vector2F) -> Transform2F {
-        self.post_mul(&Transform2DF::from_translation(vector))
+        self.post_mul(&Transform2F::from_translation(vector))
     }
 
     #[inline]
-    pub fn post_rotate(&self, theta: f32) -> Transform2DF {
+    pub fn post_rotate(&self, theta: f32) -> Transform2F {
-        self.post_mul(&Transform2DF::from_rotation(theta))
+        self.post_mul(&Transform2F::from_rotation(theta))
     }
 
     #[inline]
-    pub fn post_scale(&self, scale: Vector2F) -> Transform2DF {
+    pub fn post_scale(&self, scale: Vector2F) -> Transform2F {
-        self.post_mul(&Transform2DF::from_scale(scale))
+        self.post_mul(&Transform2F::from_scale(scale))
     }
 
     /// Returns the translation part of this matrix.

geometry/src/transform3d.rs

@@ -21,17 +21,17 @@ use std::ops::{Add, Mul, MulAssign, Neg};
 /// In column-major order.
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[repr(C)]
-pub struct Transform3DF {
+pub struct Transform4F {
     pub c0: F32x4,
     pub c1: F32x4,
     pub c2: F32x4,
     pub c3: F32x4,
 }
 
-impl Default for Transform3DF {
+impl Default for Transform4F {
     #[inline]
-    fn default() -> Transform3DF {
+    fn default() -> Transform4F {
-        Transform3DF {
+        Transform4F {
             c0: F32x4::new(1.0, 0.0, 0.0, 0.0),
             c1: F32x4::new(0.0, 1.0, 0.0, 0.0),
             c2: F32x4::new(0.0, 0.0, 1.0, 0.0),
@@ -40,7 +40,7 @@ impl Default for Transform3DF {
     }
 }
 
-impl Transform3DF {
+impl Transform4F {
     #[inline]
     pub fn row_major(
         m00: f32,
@@ -59,8 +59,8 @@ impl Transform3DF {
         m31: f32,
         m32: f32,
         m33: f32,
-    ) -> Transform3DF {
+    ) -> Transform4F {
-        Transform3DF {
+        Transform4F {
             c0: F32x4::new(m00, m10, m20, m30),
             c1: F32x4::new(m01, m11, m21, m31),
             c2: F32x4::new(m02, m12, m22, m32),
@@ -69,8 +69,8 @@ impl Transform3DF {
     }
 
     #[inline]
-    pub fn from_scale(scale: Vector4F) -> Transform3DF {
+    pub fn from_scale(scale: Vector4F) -> Transform4F {
-        Transform3DF {
+        Transform4F {
             c0: F32x4::new(scale.x(), 0.0, 0.0, 0.0),
             c1: F32x4::new(0.0, scale.y(), 0.0, 0.0),
             c2: F32x4::new(0.0, 0.0, scale.z(), 0.0),
@@ -79,18 +79,18 @@ impl Transform3DF {
     }
 
     #[inline]
-    pub fn from_uniform_scale(factor: f32) -> Transform3DF {
+    pub fn from_uniform_scale(factor: f32) -> Transform4F {
-        Transform3DF::from_scale(Vector4F::splat(factor))
+        Transform4F::from_scale(Vector4F::splat(factor))
     }
 
     #[inline]
-    pub fn from_translation(mut translation: Vector4F) -> Transform3DF {
+    pub fn from_translation(mut translation: Vector4F) -> Transform4F {
         translation.set_w(1.0);
-        Transform3DF { c3: translation.0, ..Transform3DF::default() }
+        Transform4F { c3: translation.0, ..Transform4F::default() }
     }
 
     // TODO(pcwalton): Optimize.
-    pub fn from_rotation(yaw: f32, pitch: f32, roll: f32) -> Transform3DF {
+    pub fn from_rotation(yaw: f32, pitch: f32, roll: f32) -> Transform4F {
         let (cos_b, sin_b) = (yaw.cos(), yaw.sin());
         let (cos_c, sin_c) = (pitch.cos(), pitch.sin());
         let (cos_a, sin_a) = (roll.cos(), roll.sin());
@@ -103,7 +103,7 @@ impl Transform3DF {
         let m20 = -sin_b;
         let m21 = cos_b * sin_c;
         let m22 = cos_b * cos_c;
-        Transform3DF::row_major(
+        Transform4F::row_major(
             m00, m01, m02, 0.0, m10, m11, m12, 0.0, m20, m21, m22, 0.0, 0.0, 0.0, 0.0, 1.0,
         )
     }
@@ -112,7 +112,7 @@ impl Transform3DF {
     ///
     /// The quaternion is expected to be packed into a SIMD type (x, y, z, w) corresponding to
     /// x + yi + zj + wk.
-    pub fn from_rotation_quaternion(q: F32x4) -> Transform3DF {
+    pub fn from_rotation_quaternion(q: F32x4) -> Transform4F {
         // TODO(pcwalton): Optimize better with more shuffles.
         let (mut sq, mut w, mut xy_xz_yz) = (q * q, q.wwww() * q, q.xxyy() * q.yzzy());
         sq += sq;
@@ -121,7 +121,7 @@ impl Transform3DF {
         let diag = F32x4::splat(1.0) - (sq.yxxy() + sq.zzyy());
         let (wx2, wy2, wz2) = (w.x(), w.y(), w.z());
         let (xy2, xz2, yz2) = (xy_xz_yz.x(), xy_xz_yz.y(), xy_xz_yz.z());
-        Transform3DF::row_major(
+        Transform4F::row_major(
             diag.x(),
             xy2 - wz2,
             xz2 + wy2,
@@ -150,14 +150,14 @@ impl Transform3DF {
         top: f32,
         near_val: f32,
         far_val: f32,
-    ) -> Transform3DF {
+    ) -> Transform4F {
         let x_inv = 1.0 / (right - left);
         let y_inv = 1.0 / (top - bottom);
         let z_inv = 1.0 / (far_val - near_val);
         let tx = -(right + left) * x_inv;
         let ty = -(top + bottom) * y_inv;
         let tz = -(far_val + near_val) * z_inv;
-        Transform3DF::row_major(
+        Transform4F::row_major(
             2.0 * x_inv,
             0.0,
             0.0,
@@ -178,17 +178,17 @@ impl Transform3DF {
     }
 
     /// Linearly interpolate between transforms
-    pub fn lerp(&self, weight: f32, other: &Transform3DF) -> Transform3DF {
+    pub fn lerp(&self, weight: f32, other: &Transform4F) -> Transform4F {
         let c0 = self.c0 * F32x4::splat(weight) + other.c0 * F32x4::splat(1.0 - weight);
         let c1 = self.c1 * F32x4::splat(weight) + other.c1 * F32x4::splat(1.0 - weight);
         let c2 = self.c2 * F32x4::splat(weight) + other.c2 * F32x4::splat(1.0 - weight);
         let c3 = self.c3 * F32x4::splat(weight) + other.c3 * F32x4::splat(1.0 - weight);
-        Transform3DF { c0, c1, c2, c3 }
+        Transform4F { c0, c1, c2, c3 }
     }
 
     /// Just like `gluPerspective()`.
     #[inline]
-    pub fn from_perspective(fov_y: f32, aspect: f32, z_near: f32, z_far: f32) -> Transform3DF {
+    pub fn from_perspective(fov_y: f32, aspect: f32, z_near: f32, z_far: f32) -> Transform4F {
         let f = 1.0 / (fov_y * 0.5).tan();
         let z_denom = 1.0 / (z_near - z_far);
         let m00 = f / aspect;
@@ -196,7 +196,7 @@ impl Transform3DF {
         let m22 = (z_far + z_near) * z_denom;
         let m23 = 2.0 * z_far * z_near * z_denom;
         let m32 = -1.0;
-        Transform3DF::row_major(
+        Transform4F::row_major(
             m00, 0.0, 0.0, 0.0, 0.0, m11, 0.0, 0.0, 0.0, 0.0, m22, m23, 0.0, 0.0, m32, 0.0,
         )
     }
@@ -211,8 +211,8 @@ impl Transform3DF {
         b: Matrix2x2F,
         c: Matrix2x2F,
         d: Matrix2x2F,
-    ) -> Transform3DF {
+    ) -> Transform4F {
-        Transform3DF {
+        Transform4F {
             c0: a.0.concat_xy_xy(c.0),
             c1: a.0.concat_zw_zw(c.0),
             c2: b.0.concat_xy_xy(d.0),
@@ -253,7 +253,7 @@ impl Transform3DF {
     //
     // If A is the upper left submatrix of this matrix, this method assumes that A and the Schur
     // complement of A are invertible.
-    pub fn inverse(&self) -> Transform3DF {
+    pub fn inverse(&self) -> Transform4F {
         // Extract submatrices.
         let (a, b) = (self.upper_left(), self.upper_right());
         let (c, d) = (self.lower_left(), self.lower_right());
@@ -269,10 +269,10 @@ impl Transform3DF {
         let (c_new, d_new) = ((-y).post_mul(&x), y);
 
         // Construct inverse.
-        Transform3DF::from_submatrices(a_new, b_new, c_new, d_new)
+        Transform4F::from_submatrices(a_new, b_new, c_new, d_new)
     }
 
-    pub fn approx_eq(&self, other: &Transform3DF, epsilon: f32) -> bool {
+    pub fn approx_eq(&self, other: &Transform4F, epsilon: f32) -> bool {
         self.c0.approx_eq(other.c0, epsilon)
             && self.c1.approx_eq(other.c1, epsilon)
             && self.c2.approx_eq(other.c2, epsilon)
@@ -290,13 +290,13 @@ impl Transform3DF {
     }
 }
 
-impl Mul<Transform3DF> for Transform3DF {
+impl Mul<Transform4F> for Transform4F {
-    type Output = Transform3DF;
+    type Output = Transform4F;
 
     // https://stackoverflow.com/a/18508113
     #[inline]
-    fn mul(self, other: Transform3DF) -> Transform3DF {
+    fn mul(self, other: Transform4F) -> Transform4F {
-        return Transform3DF {
+        return Transform4F {
             c0: mul_col(&self, other.c0),
             c1: mul_col(&self, other.c1),
             c2: mul_col(&self, other.c2),
@@ -304,14 +304,14 @@ impl Mul<Transform3DF> for Transform3DF {
         };
 
         #[inline]
-        fn mul_col(a: &Transform3DF, b_col: F32x4) -> F32x4 {
+        fn mul_col(a: &Transform4F, b_col: F32x4) -> F32x4 {
             a.c0 * b_col.xxxx() + a.c1 * b_col.yyyy() + a.c2 * b_col.zzzz() + a.c3 * b_col.wwww()
         }
     }
 }
 
-impl MulAssign<Transform3DF> for Transform3DF {
+impl MulAssign<Transform4F> for Transform4F {
-    fn mul_assign(&mut self, other: Transform3DF) {
+    fn mul_assign(&mut self, other: Transform4F) {
         *self = *self * other
     }
 }
@@ -334,13 +334,13 @@ impl Neg for Matrix2x2F {
 
 #[derive(Clone, Copy, Debug)]
 pub struct Perspective {
-    pub transform: Transform3DF,
+    pub transform: Transform4F,
     pub window_size: Vector2I,
 }
 
 impl Perspective {
     #[inline]
-    pub fn new(transform: &Transform3DF, window_size: Vector2I) -> Perspective {
+    pub fn new(transform: &Transform4F, window_size: Vector2I) -> Perspective {
         Perspective {
             transform: *transform,
             window_size,
@@ -371,10 +371,10 @@ impl Perspective {
     }
 }
 
-impl Mul<Transform3DF> for Perspective {
+impl Mul<Transform4F> for Perspective {
     type Output = Perspective;
     #[inline]
-    fn mul(self, other: Transform3DF) -> Perspective {
+    fn mul(self, other: Transform4F) -> Perspective {
         Perspective {
             transform: self.transform * other,
             window_size: self.window_size,
@@ -385,17 +385,17 @@ impl Mul<Transform3DF> for Perspective {
 #[cfg(test)]
 mod test {
     use crate::vector::Vector4F;
-    use crate::transform3d::Transform3DF;
+    use crate::transform3d::Transform4F;
 
     #[test]
     fn test_post_mul() {
-        let a = Transform3DF::row_major(
+        let a = Transform4F::row_major(
             3.0, 1.0, 4.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0, 5.0, 8.0, 9.0, 7.0, 9.0, 3.0, 2.0,
         );
-        let b = Transform3DF::row_major(
+        let b = Transform4F::row_major(
             3.0, 8.0, 4.0, 6.0, 2.0, 6.0, 4.0, 3.0, 3.0, 8.0, 3.0, 2.0, 7.0, 9.0, 5.0, 0.0,
         );
-        let c = Transform3DF::row_major(
+        let c = Transform4F::row_major(
             58.0, 107.0, 53.0, 29.0, 84.0, 177.0, 87.0, 72.0, 106.0, 199.0, 101.0, 49.0, 62.0,
             152.0, 83.0, 75.0,
         );
@@ -404,13 +404,13 @@ mod test {
 
     #[test]
     fn test_pre_mul() {
-        let a = Transform3DF::row_major(
+        let a = Transform4F::row_major(
             3.0, 1.0, 4.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0, 5.0, 8.0, 9.0, 7.0, 9.0, 3.0, 2.0,
         );
-        let b = Transform3DF::row_major(
+        let b = Transform4F::row_major(
             3.0, 8.0, 4.0, 6.0, 2.0, 6.0, 4.0, 3.0, 3.0, 8.0, 3.0, 2.0, 7.0, 9.0, 5.0, 0.0,
         );
-        let c = Transform3DF::row_major(
+        let c = Transform4F::row_major(
             135.0, 93.0, 110.0, 103.0, 93.0, 61.0, 85.0, 82.0, 104.0, 52.0, 90.0, 86.0, 117.0,
             50.0, 122.0, 125.0,
         );
@@ -419,7 +419,7 @@ mod test {
 
     #[test]
     fn test_transform_point() {
-        let a = Transform3DF::row_major(
+        let a = Transform4F::row_major(
             3.0, 1.0, 4.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0, 5.0, 8.0, 9.0, 7.0, 9.0, 3.0, 2.0,
         );
         let p = Vector4F::new(3.0, 8.0, 4.0, 6.0);
@@ -430,7 +430,7 @@ mod test {
     #[test]
     fn test_inverse() {
         // Random matrix.
-        let m = Transform3DF::row_major(
+        let m = Transform4F::row_major(
             0.86277982, 0.15986552, 0.90739898, 0.60066808, 0.17386167, 0.016353, 0.8535783,
             0.12969608, 0.0946466, 0.43248631, 0.63480505, 0.08154603, 0.50305436, 0.48359687,
             0.51057162, 0.24812012,
@@ -438,7 +438,7 @@ mod test {
         let p0 = Vector4F::new(0.95536648, 0.80633691, 0.16357357, 0.5477598);
         let p1 = m.transform_point(p0);
         let m_inv = m.inverse();
-        let m_inv_exp = Transform3DF::row_major(
+        let m_inv_exp = Transform4F::row_major(
             -2.47290136,
             3.48865688,
             -6.12298336,

gpu/src/lib.rs

@@ -14,7 +14,7 @@ use crate::resources::ResourceLoader;
 use image::ImageFormat;
 use pathfinder_content::color::ColorF;
 use pathfinder_geometry::rect::RectI;
-use pathfinder_geometry::transform3d::Transform3DF;
+use pathfinder_geometry::transform3d::Transform4F;
 use pathfinder_geometry::vector::Vector2I;
 use pathfinder_simd::default::{F32x2, F32x4};
 use std::time::Duration;
@@ -286,7 +286,7 @@ pub enum TextureData {
 
 impl UniformData {
     #[inline]
-    pub fn from_transform_3d(transform: &Transform3DF) -> UniformData {
+    pub fn from_transform_3d(transform: &Transform4F) -> UniformData {
         UniformData::Mat4([transform.c0, transform.c1, transform.c2, transform.c3])
     }
 }

renderer/src/gpu/renderer.rs

@@ -16,7 +16,7 @@ use crate::post::DefringingKernel;
 use crate::tiles::{TILE_HEIGHT, TILE_WIDTH};
 use pathfinder_geometry::vector::{Vector2I, Vector4F};
 use pathfinder_geometry::rect::RectI;
-use pathfinder_geometry::transform3d::Transform3DF;
+use pathfinder_geometry::transform3d::Transform4F;
 use pathfinder_content::color::ColorF;
 use pathfinder_gpu::resources::ResourceLoader;
 use pathfinder_gpu::{BlendState, BufferData, BufferTarget, BufferUploadMode, ClearOps};
@@ -468,14 +468,14 @@ where
         self.buffered_fills.clear();
     }
 
-    fn tile_transform(&self) -> Transform3DF {
+    fn tile_transform(&self) -> Transform4F {
         let draw_viewport = self.draw_viewport().size().to_f32();
         let scale = F32x2::new(2.0 / draw_viewport.x(), -2.0 / draw_viewport.y());
-        let transform = Transform3DF::from_scale(Vector4F::new(2.0 / draw_viewport.x(),
+        let transform = Transform4F::from_scale(Vector4F::new(2.0 / draw_viewport.x(),
                                                                -2.0 / draw_viewport.y(),
                                                                1.0,
                                                                1.0));
-        Transform3DF::from_translation(Vector4F::new(-1.0, 1.0, 0.0, 1.0)) * transform
+        Transform4F::from_translation(Vector4F::new(-1.0, 1.0, 0.0, 1.0)) * transform
     }
 
     fn draw_alpha_tiles(&mut self, count: u32) {
@@ -738,8 +738,8 @@ where
     pub fn reproject_texture(
         &mut self,
         texture: &D::Texture,
-        old_transform: &Transform3DF,
+        old_transform: &Transform4F,
-        new_transform: &Transform3DF,
+        new_transform: &Transform4F,
     ) {
         let clear_color = self.clear_color_for_draw_operation();
 

renderer/src/options.rs

@@ -12,7 +12,7 @@
 
 use crate::gpu_data::RenderCommand;
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_geometry::transform3d::Perspective;
 use pathfinder_geometry::vector::{Vector2F, Vector4F};
 use pathfinder_content::clip::PolygonClipper3D;
@@ -51,14 +51,14 @@ impl BuildOptions {
 
 #[derive(Clone)]
 pub enum RenderTransform {
-    Transform2D(Transform2DF),
+    Transform2D(Transform2F),
     Perspective(Perspective),
 }
 
 impl Default for RenderTransform {
     #[inline]
     fn default() -> RenderTransform {
-        RenderTransform::Transform2D(Transform2DF::default())
+        RenderTransform::Transform2D(Transform2F::default())
     }
 }
 
@@ -140,7 +140,7 @@ pub(crate) type BoundingQuad = [Vector4F; 4];
 
 pub(crate) enum PreparedRenderTransform {
     None,
-    Transform2D(Transform2DF),
+    Transform2D(Transform2F),
     Perspective {
         perspective: Perspective,
         clip_polygon: Vec<Vector2F>,

renderer/src/scene.rs

@@ -18,7 +18,7 @@ use crate::paint::{Paint, PaintId};
 use hashbrown::HashMap;
 use pathfinder_geometry::vector::Vector2F;
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_content::color::ColorU;
 use pathfinder_content::outline::Outline;
 
@@ -115,12 +115,12 @@ impl Scene {
                 if options.transform.is_2d() || options.subpixel_aa_enabled {
                     let mut transform = match options.transform {
                         PreparedRenderTransform::Transform2D(transform) => transform,
-                        PreparedRenderTransform::None => Transform2DF::default(),
+                        PreparedRenderTransform::None => Transform2F::default(),
                         PreparedRenderTransform::Perspective { .. } => unreachable!(),
                     };
                     if options.subpixel_aa_enabled {
                         transform = transform
-                            .post_mul(&Transform2DF::from_scale(Vector2F::new(3.0, 1.0)))
+                            .post_mul(&Transform2F::from_scale(Vector2F::new(3.0, 1.0)))
                     }
                     outline.transform(&transform);
                 }

svg/src/lib.rs

@@ -17,10 +17,10 @@ use pathfinder_content::color::ColorU;
 use pathfinder_content::outline::Outline;
 use pathfinder_content::segment::{Segment, SegmentFlags};
 use pathfinder_content::stroke::{LineCap, LineJoin, OutlineStrokeToFill, StrokeStyle};
-use pathfinder_content::transform::Transform2DFPathIter;
+use pathfinder_content::transform::Transform2FPathIter;
 use pathfinder_geometry::line_segment::LineSegment2F;
 use pathfinder_geometry::rect::RectF;
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_geometry::vector::Vector2F;
 use pathfinder_renderer::paint::Paint;
 use pathfinder_renderer::scene::{PathObject, Scene};
@@ -62,7 +62,7 @@ bitflags! {
 impl BuiltSVG {
     // TODO(pcwalton): Allow a global transform to be set.
     pub fn from_tree(tree: Tree) -> BuiltSVG {
-        let global_transform = Transform2DF::default();
+        let global_transform = Transform2F::default();
 
         let mut built_svg = BuiltSVG {
             scene: Scene::new(),
@@ -87,7 +87,7 @@ impl BuiltSVG {
         built_svg
     }
 
-    fn process_node(&mut self, node: &Node, transform: &Transform2DF) {
+    fn process_node(&mut self, node: &Node, transform: &Transform2F) {
         let node_transform = usvg_transform_to_transform_2d(&node.transform());
         let transform = transform.pre_mul(&node_transform);
 
@@ -119,7 +119,7 @@ impl BuiltSVG {
                     ));
 
                     let path = UsvgPathToSegments::new(path.segments.iter().cloned());
-                    let path = Transform2DFPathIter::new(path, &transform);
+                    let path = Transform2FPathIter::new(path, &transform);
                     let outline = Outline::from_segments(path);
 
                     let name = format!("Fill({})", node.id());
@@ -266,8 +266,8 @@ fn usvg_rect_to_euclid_rect(rect: &UsvgRect) -> RectF {
     )
 }
 
-fn usvg_transform_to_transform_2d(transform: &UsvgTransform) -> Transform2DF {
+fn usvg_transform_to_transform_2d(transform: &UsvgTransform) -> Transform2F {
-    Transform2DF::row_major(
+    Transform2F::row_major(
         transform.a as f32,
         transform.b as f32,
         transform.c as f32,

text/src/lib.rs

@@ -15,7 +15,7 @@ use font_kit::loader::Loader;
 use lyon_path::builder::{FlatPathBuilder, PathBuilder};
 use pathfinder_content::outline::{Contour, Outline};
 use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle};
-use pathfinder_geometry::transform2d::Transform2DF;
+use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_geometry::vector::Vector2F;
 use pathfinder_renderer::paint::PaintId;
 use pathfinder_renderer::scene::{PathObject, Scene};
@@ -27,7 +27,7 @@ pub trait SceneExt {
     fn push_glyph<F>(&mut self,
                      font: &F,
                      glyph_id: u32,
-                     transform: &Transform2DF,
+                     transform: &Transform2F,
                      render_mode: TextRenderMode,
                      hinting_options: HintingOptions,
                      paint_id: PaintId)
@@ -37,7 +37,7 @@ pub trait SceneExt {
     fn push_layout(&mut self,
                    layout: &Layout,
                    style: &TextStyle,
-                   transform: &Transform2DF,
+                   transform: &Transform2F,
                    render_mode: TextRenderMode,
                    hinting_options: HintingOptions,
                    paint_id: PaintId)
@@ -47,7 +47,7 @@ pub trait SceneExt {
                  text: &str,
                  style: &TextStyle,
                  collection: &FontCollection,
-                 transform: &Transform2DF,
+                 transform: &Transform2F,
                  render_mode: TextRenderMode,
                  hinting_options: HintingOptions,
                  paint_id: PaintId)
@@ -59,7 +59,7 @@ impl SceneExt for Scene {
     fn push_glyph<F>(&mut self,
                      font: &F,
                      glyph_id: u32,
-                     transform: &Transform2DF,
+                     transform: &Transform2F,
                      render_mode: TextRenderMode,
                      hinting_options: HintingOptions,
                      paint_id: PaintId)
@@ -82,7 +82,7 @@ impl SceneExt for Scene {
     fn push_layout(&mut self,
                    layout: &Layout,
                    style: &TextStyle,
-                   transform: &Transform2DF,
+                   transform: &Transform2F,
                    render_mode: TextRenderMode,
                    hinting_options: HintingOptions,
                    paint_id: PaintId)
@@ -94,7 +94,7 @@ impl SceneExt for Scene {
             let scale = style.size / (font.metrics().units_per_em as f32);
             let scale = Vector2F::new(scale, -scale);
             let transform =
-                Transform2DF::from_scale(scale).post_translate(offset).post_mul(transform);
+                Transform2F::from_scale(scale).post_translate(offset).post_mul(transform);
             self.push_glyph(font,
                             glyph.glyph_id,
                             &transform,
@@ -110,7 +110,7 @@ impl SceneExt for Scene {
                  text: &str,
                  style: &TextStyle,
                  collection: &FontCollection,
-                 transform: &Transform2DF,
+                 transform: &Transform2F,
                  render_mode: TextRenderMode,
                  hinting_options: HintingOptions,
                  paint_id: PaintId)
@@ -129,11 +129,11 @@ pub enum TextRenderMode {
 struct OutlinePathBuilder {
     outline: Outline,
     current_contour: Contour,
-    transform: Transform2DF,
+    transform: Transform2F,
 }
 
 impl OutlinePathBuilder {
-    fn new(transform: &Transform2DF) -> OutlinePathBuilder {
+    fn new(transform: &Transform2F) -> OutlinePathBuilder {
         OutlinePathBuilder {
             outline: Outline::new(),
             current_contour: Contour::new(),