Switch scale and translation constructors for `Transform3DF` over to use vectors

demo/common/src/camera.rs

@@ -70,10 +70,10 @@ impl Camera {
 
         // Create a scene transform by moving the camera back from the center of the eyes so that
         // its field of view encompasses the field of view of both eyes.
-        let z_offset = -DEFAULT_EYE_OFFSET * projection.c0.x();
+        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(0.0, 0.0, z_offset),
+            modelview_to_eye: Transform3DF::from_translation(z_offset),
         };
 
         // For now, initialize the eye transforms as copies of the scene transform.
@@ -85,9 +85,10 @@ impl Camera {
                 } else {
                     -eye_offset
                 };
+                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, 0.0, 0.0),
+                    modelview_to_eye: Transform3DF::from_translation(this_eye_offset),
                 }
             })
             .collect();
@@ -154,12 +155,11 @@ impl CameraTransform3D {
     pub fn to_transform(&self) -> Transform3DF {
         let mut transform = Transform3DF::from_rotation(self.yaw, self.pitch, 0.0);
         transform *= Transform3DF::from_uniform_scale(2.0 * self.scale);
-        transform *= Transform3DF::from_translation(-self.position.x(),
+        transform *=
-                                                    -self.position.y(),
+            Transform3DF::from_translation(self.position * Vector4F::new(-1.0, -1.0, -1.0, 1.0));
-                                                    -self.position.z());
 
         // Flip Y.
-        transform *= Transform3DF::from_scale(1.0, -1.0, 1.0);
+        transform *= Transform3DF::from_scale(Vector4F::new(1.0, -1.0, 1.0, 1.0));
 
         transform
     }

demo/common/src/lib.rs

@@ -22,12 +22,12 @@ use crate::device::{GroundProgram, GroundVertexArray};
 use crate::ui::{DemoUIModel, DemoUIPresenter, ScreenshotInfo, ScreenshotType, UIAction};
 use crate::window::{Event, Keycode, SVGPath, Window, WindowSize};
 use clap::{App, Arg};
+use pathfinder_content::color::ColorU;
 use pathfinder_export::{Export, FileFormat};
-use pathfinder_geometry::vector::{Vector2F, Vector2I};
 use pathfinder_geometry::rect::RectF;
 use pathfinder_geometry::transform2d::Transform2DF;
 use pathfinder_geometry::transform3d::Transform3DF;
-use pathfinder_content::color::ColorU;
+use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F};
 use pathfinder_gpu::resources::ResourceLoader;
 use pathfinder_gpu::Device;
 use pathfinder_renderer::concurrent::scene_proxy::{RenderCommandStream, SceneProxy};
@@ -366,8 +366,9 @@ impl<W> DemoApp<W> where W: Window {
                         // TODO: calculate the eye offset from the eye transforms?
                         let z_offset = -DEFAULT_EYE_OFFSET *
                             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(0.0, 0.0, z_offset) *
+                            Transform3DF::from_translation(z_offset) *
                             scene_transform.modelview_to_eye;
                     }
                 }

demo/common/src/renderer.rs

@@ -19,7 +19,7 @@ use pathfinder_gpu::{ClearOps, DepthFunc, DepthState, Device, Primitive, RenderO
 use pathfinder_gpu::{RenderState, RenderTarget, TextureData, TextureFormat, UniformData};
 use pathfinder_geometry::rect::RectI;
 use pathfinder_geometry::transform3d::Transform3DF;
-use pathfinder_geometry::vector::Vector2I;
+use pathfinder_geometry::vector::{Vector2I, Vector4F};
 use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
 use pathfinder_renderer::gpu::renderer::RenderMode;
 use pathfinder_renderer::gpu_data::RenderCommand;
@@ -163,11 +163,9 @@ impl<W> DemoApp<W> where W: Window {
         let scene_framebuffer = self.scene_framebuffer.as_ref().unwrap();
         let scene_texture = self.renderer.device.framebuffer_texture(scene_framebuffer);
 
-        let quad_scale_transform = Transform3DF::from_scale(
+        let mut quad_scale = self.scene_metadata.view_box.size().to_3d();
-            self.scene_metadata.view_box.size().x(),
+        quad_scale.set_z(1.0);
-            self.scene_metadata.view_box.size().y(),
+        let quad_scale_transform = Transform3DF::from_scale(quad_scale);
-            1.0,
-        );
 
         let scene_transform_matrix = scene_transform.perspective *
             scene_transform.modelview_to_eye *
@@ -212,13 +210,14 @@ impl<W> DemoApp<W> where W: Window {
 
         let ground_scale = self.scene_metadata.view_box.max_x() * 2.0;
 
-        let base_transform = perspective.transform *
+        let mut offset = self.scene_metadata.view_box.lower_right().to_3d();
-            Transform3DF::from_translation(-0.5 * self.scene_metadata.view_box.max_x(),
+        offset.set_z(ground_scale);
-                                           self.scene_metadata.view_box.max_y(),
+        offset = offset * Vector4F::new(-0.5, 1.0, -0.5, 1.0);
-                                           -0.5 * ground_scale);
+        let base_transform = perspective.transform * Transform3DF::from_translation(offset);
 
         // Fill ground.
-        let transform = base_transform * Transform3DF::from_scale(ground_scale, 1.0, ground_scale);
+        let transform = base_transform *    
+            Transform3DF::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 {

geometry/src/transform3d.rs

@@ -69,22 +69,24 @@ impl Transform3DF {
     }
 
     #[inline]
-    pub fn from_scale(x: f32, y: f32, z: f32) -> Transform3DF {
+    pub fn from_scale(scale: Vector4F) -> Transform3DF {
-        Transform3DF::row_major(
+        Transform3DF {
-            x, 0.0, 0.0, 0.0, 0.0, y, 0.0, 0.0, 0.0, 0.0, z, 0.0, 0.0, 0.0, 0.0, 1.0,
+            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),
+            c3: F32x4::new(0.0, 0.0, 0.0,       1.0),
+        }
     }
 
     #[inline]
     pub fn from_uniform_scale(factor: f32) -> Transform3DF {
-        Transform3DF::from_scale(factor, factor, factor)
+        Transform3DF::from_scale(Vector4F::splat(factor))
     }
 
     #[inline]
-    pub fn from_translation(x: f32, y: f32, z: f32) -> Transform3DF {
+    pub fn from_translation(mut translation: Vector4F) -> Transform3DF {
-        Transform3DF::row_major(
+        translation.set_w(1.0);
-            1.0, 0.0, 0.0, x, 0.0, 1.0, 0.0, y, 0.0, 0.0, 1.0, z, 0.0, 0.0, 0.0, 1.0,
+        Transform3DF { c3: translation.0, ..Transform3DF::default() }
-        )
     }
 
     // TODO(pcwalton): Optimize.

renderer/src/gpu/renderer.rs

@@ -471,8 +471,11 @@ where
     fn tile_transform(&self) -> Transform3DF {
         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(scale.x(), scale.y(), 1.0);
+        let transform = Transform3DF::from_scale(Vector4F::new(2.0 / draw_viewport.x(),
-        Transform3DF::from_translation(-1.0, 1.0, 0.0) * transform
+                                                               -2.0 / draw_viewport.y(),
+                                                               1.0,
+                                                               1.0));
+        Transform3DF::from_translation(Vector4F::new(-1.0, 1.0, 0.0, 1.0)) * transform
     }
 
     fn draw_alpha_tiles(&mut self, count: u32) {