render: Render Matrix3D tz element

In Transform.Matrix3D setter, the transformation matrix was
crushed to 2D, ignoring 3D parameters.
This commit picks up tz element (i.e. raw_data[14] element) into
render.Transform and take it into account in wgpu rendering.
The projection matrix for the default perspective projection
(FOV: 55.0 deg, center: stage center) is introduced to rendering.

Author: cookie-s

core/src/avm1/globals/bitmap_data.rs

@@ -577,6 +577,7 @@ fn draw<'gc>(
                 Transform {
                     matrix,
                     color_transform,
+                    tz: 0.0,
                 },
                 smoothing,
                 blend_mode,

core/src/avm2/globals/flash/geom/transform.rs

@@ -364,6 +364,8 @@ pub fn set_matrix_3d<'gc>(
             Some(obj) => {
                 let matrix3d = object_to_matrix3d(obj, activation)?;
                 let matrix = Matrix::from(matrix3d);
+                let tz = matrix3d.tz();
+                display_object.base_mut(activation.gc()).set_tz(tz);
                 (matrix, true)
             }
             None => (Matrix::IDENTITY, false),

core/src/display_object.rs

@@ -336,6 +336,10 @@ impl<'gc> DisplayObjectBase<'gc> {
         &mut self.transform.matrix
     }
 
+    pub fn set_tz(&mut self, tz: f64) {
+        self.transform.tz = tz;
+    }
+
     pub fn set_matrix(&mut self, matrix: Matrix) {
         self.transform.matrix = matrix;
         self.set_scale_rotation_cached(false);
@@ -941,6 +945,7 @@ pub fn render_base<'gc>(this: DisplayObject<'gc>, context: &mut RenderContext<'_
                     ty: -offset_y,
                     ..cache_info.base_transform.matrix
                 },
+                tz: 0.0,
             });
             let mut offscreen_context = RenderContext {
                 renderer: context.renderer,
@@ -973,6 +978,7 @@ pub fn render_base<'gc>(this: DisplayObject<'gc>, context: &mut RenderContext<'_
                         ..Default::default()
                     },
                     color_transform: cache_info.base_transform.color_transform,
+                    tz: context.transform_stack.transform().tz,
                 },
                 true,
                 PixelSnapping::Always, // cacheAsBitmap forces pixel snapping
@@ -1045,6 +1051,7 @@ pub fn apply_standard_mask_and_scroll<'gc, F>(
         context.transform_stack.push(&Transform {
             matrix: Matrix::translate(-rect.x_min, -rect.y_min),
             color_transform: Default::default(),
+            tz: 0.0,
         });
     }
 

core/src/display_object/edit_text.rs

@@ -1303,6 +1303,7 @@ impl<'gc> EditText<'gc> {
                             context.transform_stack.push(&Transform {
                                 matrix: transform.matrix,
                                 color_transform: ColorTransform::IDENTITY,
+                                tz: 0.0,
                             });
                         } else {
                             context.transform_stack.push(transform);

core/src/display_object/stage.rs

@@ -834,6 +834,7 @@ impl<'gc> TDisplayObject<'gc> for Stage<'gc> {
         context.transform_stack.push(&Transform {
             matrix: self.0.read().viewport_matrix,
             color_transform: Default::default(),
+            tz: 0.0,
         });
 
         // All of our Stage3D instances get rendered *underneath* the main stage.

render/src/matrix3d.rs

@@ -48,3 +48,37 @@ impl From<Matrix3D> for Matrix {
         }
     }
 }
+
+impl Matrix3D {
+    pub const ZERO: Self = Self {
+        raw_data: [0.0; 16],
+    };
+    pub const IDENTITY: Self = Self {
+        raw_data: [
+            1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
+        ],
+    };
+
+    pub fn tz(&self) -> f64 {
+        self.raw_data[14]
+    }
+    pub fn set_tz(&mut self, tz: f64) {
+        self.raw_data[14] = tz;
+    }
+}
+
+impl std::ops::Mul for Matrix3D {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        let mut res = Matrix3D::ZERO;
+        for i in 0..4 {
+            for j in 0..4 {
+                for k in 0..4 {
+                    res.raw_data[i + 4 * j] += self.raw_data[i + 4 * k] * rhs.raw_data[k + 4 * j];
+                }
+            }
+        }
+        res
+    }
+}

render/src/transform.rs

@@ -6,6 +6,7 @@ use swf::ColorTransform;
 #[derive(Clone, Debug, Default)]
 pub struct Transform {
     pub matrix: Matrix,
+    pub tz: f64,
     pub color_transform: ColorTransform,
 }
 
@@ -20,9 +21,11 @@ impl TransformStack {
         let cur_transform = self.transform();
         let matrix = cur_transform.matrix * transform.matrix;
         let color_transform = cur_transform.color_transform * transform.color_transform;
+        let tz = cur_transform.tz + transform.tz;
         self.0.push(Transform {
             matrix,
             color_transform,
+            tz,
         });
     }
 

render/wgpu/src/globals.rs

@@ -1,5 +1,6 @@
 //use super::utils::create_debug_label;
 use bytemuck::{Pod, Zeroable};
+use ruffle_render::matrix3d::Matrix3D;
 use wgpu::util::DeviceExt;
 
 #[derive(Debug)]
@@ -21,16 +22,82 @@ impl Globals {
         viewport_width: u32,
         viewport_height: u32,
     ) -> Self {
+        let view_matrix = Matrix3D {
+            raw_data: [
+                1.0 / (viewport_width as f64 / 2.0),
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                -1.0 / (viewport_height as f64 / 2.0),
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                1.0 / (viewport_width as f64 / 2.0),
+                0.0,
+                -1.0,
+                1.0,
+                0.0,
+                1.0,
+            ],
+        };
+
+        let projection_matrix = {
+            // TODO: Here, just the fixed default value is used.
+            // This should support variable values derived for each display object.
+            let field_of_view = 55.0;
+
+            let focal_length = {
+                let deg2rad = f64::acos(-1.0) / 180.0;
+                let rad = field_of_view / 2.0 * deg2rad;
+                f64::cos(rad) / f64::sin(rad)
+            };
+
+            let perspective_projection = {
+                let mut m = Matrix3D::IDENTITY;
+                m.raw_data[0] = focal_length;
+                m.raw_data[5] = focal_length;
+                m.raw_data[10] = focal_length;
+                m.raw_data[11] = 1.0;
+                m.raw_data[14] = 0.0;
+                m.raw_data[15] = 0.0;
+                m
+            };
+            let move_coord = {
+                // AS3 places Viewpoint at (0, 0, -focalLength).
+
+                let mut m = Matrix3D::IDENTITY;
+                m.raw_data[14] = focal_length;
+                // TODO: Consider PerspectiveProjection.projectionCenter.
+                m
+            };
+            let move_coord_back = {
+                let mut m = Matrix3D::IDENTITY;
+                m.raw_data[10] = 0.0;
+                // TODO: Consider PerspectiveProjection.projectionCenter.
+                m
+            };
+            move_coord_back * perspective_projection * move_coord
+        };
+
+        let matrix = projection_matrix * view_matrix;
+        let matrix = {
+            let mut m = [[0.0; 4]; 4];
+            #[allow(clippy::needless_range_loop)]
+            for i in 0..4 {
+                for j in 0..4 {
+                    m[j][i] = matrix.raw_data[i + 4 * j] as f32;
+                }
+            }
+            m
+        };
+
         let temp_label = create_debug_label!("Globals buffer");
         let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
             label: temp_label.as_deref(),
             contents: bytemuck::cast_slice(&[GlobalsUniform {
-                view_matrix: [
-                    [1.0 / (viewport_width as f32 / 2.0), 0.0, 0.0, 0.0],
-                    [0.0, -1.0 / (viewport_height as f32 / 2.0), 0.0, 0.0],
-                    [0.0, 0.0, 1.0, 0.0],
-                    [-1.0, 1.0, 0.0, 1.0],
-                ],
+                view_matrix: matrix,
             }]),
             usage: wgpu::BufferUsages::UNIFORM,
         });

render/wgpu/src/surface/commands.rs

@@ -564,6 +564,7 @@ impl<'a> WgpuCommandHandler<'a> {
     fn add_to_current(
         &mut self,
         matrix: Matrix,
+        tz: f64,
         color_transform: ColorTransform,
         command_builder: impl FnOnce(wgpu::DynamicOffset) -> DrawCommand,
     ) {
@@ -575,7 +576,7 @@ impl<'a> WgpuCommandHandler<'a> {
                 [
                     matrix.tx.to_pixels() as f32,
                     matrix.ty.to_pixels() as f32,
-                    0.0,
+                    tz as f32,
                     1.0,
                 ],
             ],
@@ -642,6 +643,7 @@ impl CommandHandler for WgpuCommandHandler<'_> {
                 let transform = Transform {
                     matrix: Matrix::scale(target.width() as f32, target.height() as f32),
                     color_transform: Default::default(),
+                    tz: 0.0,
                 };
                 let texture = target.take_color_texture();
                 let bind_group =
@@ -673,6 +675,7 @@ impl CommandHandler for WgpuCommandHandler<'_> {
                         });
                 self.add_to_current(
                     transform.matrix,
+                    transform.tz,
                     transform.color_transform,
                     |transform_buffer| DrawCommand::RenderTexture {
                         _texture: texture,
@@ -726,15 +729,18 @@ impl CommandHandler for WgpuCommandHandler<'_> {
                 texture.texture.height() as f32,
             );
         }
-        self.add_to_current(matrix, transform.color_transform, |transform_buffer| {
-            DrawCommand::RenderBitmap {
+        self.add_to_current(
+            matrix,
+            transform.tz,
+            transform.color_transform,
+            |transform_buffer| DrawCommand::RenderBitmap {
                 bitmap,
                 transform_buffer,
                 smoothing,
                 blend_mode: TrivialBlend::Normal,
                 render_stage3d: false,
-            }
-        });
+            },
+        );
     }
     fn render_stage3d(&mut self, bitmap: BitmapHandle, transform: Transform) {
         let mut matrix = transform.matrix;
@@ -745,20 +751,24 @@ impl CommandHandler for WgpuCommandHandler<'_> {
                 texture.texture.height() as f32,
             );
         }
-        self.add_to_current(matrix, transform.color_transform, |transform_buffer| {
-            DrawCommand::RenderBitmap {
+        self.add_to_current(
+            matrix,
+            transform.tz,
+            transform.color_transform,
+            |transform_buffer| DrawCommand::RenderBitmap {
                 bitmap,
                 transform_buffer,
                 smoothing: false,
                 blend_mode: TrivialBlend::Normal,
                 render_stage3d: true,
-            }
-        });
+            },
+        );
     }
 
     fn render_shape(&mut self, shape: ShapeHandle, transform: Transform) {
         self.add_to_current(
             transform.matrix,
+            transform.tz,
             transform.color_transform,
             |transform_buffer| DrawCommand::RenderShape {
                 shape,
@@ -770,6 +780,7 @@ impl CommandHandler for WgpuCommandHandler<'_> {
     fn draw_rect(&mut self, color: Color, matrix: Matrix) {
         self.add_to_current(
             matrix,
+            0.0,
             ColorTransform::multiply_from(color),
             |transform_buffer| DrawCommand::DrawRect { transform_buffer },
         );
@@ -785,6 +796,7 @@ impl CommandHandler for WgpuCommandHandler<'_> {
             matrix.ty += Twips::HALF_PX;
             self.add_to_current(
                 matrix,
+                0.0,
                 ColorTransform::multiply_from(color),
                 |transform_buffer| DrawCommand::DrawLine { transform_buffer },
             );
@@ -801,6 +813,7 @@ impl CommandHandler for WgpuCommandHandler<'_> {
             matrix.ty += Twips::HALF_PX;
             self.add_to_current(
                 matrix,
+                0.0,
                 ColorTransform::multiply_from(color),
                 |transform_buffer| DrawCommand::DrawLineRect { transform_buffer },
             );