render: Implement reposition in Z-axis

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/display/display_object.rs

@@ -412,20 +412,30 @@ pub fn set_y<'gc>(
 }
 
 pub fn get_z<'gc>(
-    activation: &mut Activation<'_, 'gc>,
-    _this: Value<'gc>,
+    _activation: &mut Activation<'_, 'gc>,
+    this: Value<'gc>,
     _args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error<'gc>> {
-    avm2_stub_getter!(activation, "flash.display.DisplayObject", "z");
-    Ok(0.into())
+    let this = this.as_object().unwrap();
+
+    if let Some(dobj) = this.as_display_object() {
+        return Ok(dobj.z().into());
+    }
+    Ok(Value::Undefined)
 }
 
 pub fn set_z<'gc>(
     activation: &mut Activation<'_, 'gc>,
-    _this: Value<'gc>,
-    _args: &[Value<'gc>],
+    this: Value<'gc>,
+    args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error<'gc>> {
-    avm2_stub_setter!(activation, "flash.display.DisplayObject", "z");
+    let this = this.as_object().unwrap();
+
+    if let Some(dobj) = this.as_display_object() {
+        let z = args.get_f64(activation, 0)?;
+        dobj.set_z(activation.gc(), z);
+        dobj.base_mut(activation.gc()).set_has_matrix3d_stub(true);
+    }
     Ok(Value::Undefined)
 }
 

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

@@ -339,7 +339,8 @@ pub fn get_matrix_3d<'gc>(
     let display_object = get_display_object(this);
     if display_object.base().has_matrix3d_stub() {
         let matrix = *get_display_object(this).base().matrix();
-        let matrix3d = Matrix3D::from(matrix);
+        let mut matrix3d = Matrix3D::from(matrix);
+        matrix3d.set_tz(display_object.z());
         matrix3d_to_object(matrix3d, activation)
     } else {
         Ok(Value::Null)
@@ -359,17 +360,19 @@ pub fn set_matrix_3d<'gc>(
 
     let display_object = get_display_object(this);
 
-    let (matrix, has_matrix3d) = {
+    let (matrix, has_matrix3d, tz) = {
         match args.try_get_object(activation, 0) {
             Some(obj) => {
                 let matrix3d = object_to_matrix3d(obj, activation)?;
                 let matrix = Matrix::from(matrix3d);
-                (matrix, true)
+                let tz = matrix3d.tz();
+                (matrix, true, tz)
             }
-            None => (Matrix::IDENTITY, false),
+            None => (Matrix::IDENTITY, false, 0.0),
         }
     };
 
+    display_object.base_mut(activation.gc()).set_matrix_tz(tz);
     display_object.set_matrix(activation.gc(), matrix);
     if let Some(parent) = display_object.parent() {
         // Self-transform changes are automatically handled,

core/src/display_object.rs

@@ -336,6 +336,14 @@ impl<'gc> DisplayObjectBase<'gc> {
         &mut self.transform.matrix
     }
 
+    pub fn matrix_tz(&mut self) -> f64 {
+        self.transform.tz
+    }
+
+    pub fn set_matrix_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);
@@ -375,6 +383,17 @@ impl<'gc> DisplayObjectBase<'gc> {
         changed
     }
 
+    fn z(&self) -> f64 {
+        self.transform.tz
+    }
+
+    fn set_z(&mut self, tz: f64) -> bool {
+        let changed = self.matrix_tz() != tz;
+        self.set_transformed_by_script(true);
+        self.set_matrix_tz(tz);
+        changed
+    }
+
     /// Caches the scale and rotation factors for this display object, if necessary.
     /// Calculating these requires heavy trig ops, so we only do it when `_xscale`, `_yscale` or
     /// `_rotation` is accessed.
@@ -941,6 +960,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 +993,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 +1066,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,
         });
     }
 
@@ -1373,6 +1395,25 @@ pub trait TDisplayObject<'gc>:
         }
     }
 
+    /// The `z` position in pixels of this display object in local space.
+    /// Returned by the `_z`/`z` ActionScript properties.
+    fn z(&self) -> f64 {
+        self.base().z()
+    }
+
+    /// Sets the `z` position of this display object in local space.
+    /// Set by the `_z`/`z` ActionScript properties.
+    /// This invalidates any ancestors cacheAsBitmap automatically.
+    fn set_z(&self, gc_context: &Mutation<'gc>, z: f64) {
+        if self.base_mut(gc_context).set_z(z) {
+            if let Some(parent) = self.parent() {
+                // Self-transform changes are automatically handled,
+                // we only want to inform ancestors to avoid unnecessary invalidations for tx/ty
+                parent.invalidate_cached_bitmap(gc_context);
+            }
+        }
+    }
+
     /// The rotation in degrees this display object in local space.
     /// Returned by the `_rotation`/`rotation` ActionScript properties.
     fn rotation(&self, gc_context: &Mutation<'gc>) -> Degrees {

core/src/display_object/edit_text.rs

@@ -1255,6 +1255,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/shaders/blend/alpha.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/darken.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/difference.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/erase.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/hardlight.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/invert.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/lighten.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/multiply.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }
 

render/wgpu/shaders/blend/overlay.wgsl

@@ -12,8 +12,8 @@ struct VertexOutput {
 
 @vertex
 fn main_vertex(in: common__VertexInput) -> VertexOutput {
-    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 1.0, 1.0);
-    let uv = vec2<f32>((pos.x + 1.0) / 2.0, -((pos.y - 1.0) / 2.0));
+    let pos = common__globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
+    let uv = vec2<f32>(in.position.xy);
     return VertexOutput(pos, uv);
 }