avm2: Move PerspectiveProjection computation to render crate

Author: cookie-s

core/src/avm2/globals/flash/geom/PerspectiveProjection.as

@@ -28,14 +28,6 @@ package flash.geom {
 
         public native function set projectionCenter(value:Point);
 
-        public function toMatrix3D():Matrix3D {
-            var fl: Number = this.focalLength;
-            return new Matrix3D(new <Number>[
-                fl, 0, 0, 0,
-                0, fl, 0, 0,
-                0, 0, 1, 1,
-                0, 0, 0, 0
-            ]);
-        }
+        public native function toMatrix3D():Matrix3D;
     }
 }

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

@@ -1,14 +1,13 @@
-use std::f64::consts::PI;
-
 use crate::avm2::error::argument_error;
-use crate::avm2::globals::flash::geom::transform::object_to_perspective_projection;
+use crate::avm2::globals::flash::geom::transform::{
+    matrix3d_to_object, object_to_perspective_projection,
+};
 use crate::avm2::globals::slots::flash_geom_perspective_projection as pp_slots;
 use crate::avm2::globals::slots::flash_geom_point as point_slots;
 use crate::avm2::{Activation, Error, Object, TObject, Value};
 use crate::avm2_stub_setter;
 use crate::display_object::TDisplayObject;
-
-const DEG2RAD: f64 = PI / 180.0;
+use ruffle_render::perspective_projection::PerspectiveProjection;
 
 fn get_width<'gc>(activation: &mut Activation<'_, 'gc>, this: Object<'gc>) -> f64 {
     let dobj = this
@@ -33,10 +32,9 @@ pub fn get_focal_length<'gc>(
 ) -> Result<Value<'gc>, Error<'gc>> {
     let this = this.as_object().unwrap();
 
-    let fov = object_to_perspective_projection(this, activation)?.field_of_view;
-
     let width = get_width(activation, this);
-    let focal_length = (width / 2.0) as f32 * f64::tan((PI - fov * DEG2RAD) / 2.0) as f32;
+    let focal_length =
+        object_to_perspective_projection(this, activation)?.focal_length(width as f32);
 
     Ok(focal_length.into())
 }
@@ -66,7 +64,7 @@ pub fn set_focal_length<'gc>(
     sync_from_display_object(activation, this)?;
 
     let width = get_width(activation, this);
-    let fov = f64::atan((width / 2.0) / focal_length) / DEG2RAD * 2.0;
+    let fov = PerspectiveProjection::from_focal_length(focal_length, width).field_of_view;
     this.set_slot(pp_slots::FOV, fov.into(), activation)?;
 
     sync_to_display_object(activation, this)?;
@@ -159,6 +157,19 @@ pub fn set_projection_center<'gc>(
     Ok(Value::Undefined)
 }
 
+pub fn to_matrix_3d<'gc>(
+    activation: &mut Activation<'_, 'gc>,
+    this: Value<'gc>,
+    _args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error<'gc>> {
+    let this = this.as_object().unwrap();
+
+    let width = get_width(activation, this);
+    let matrix3d = object_to_perspective_projection(this, activation)?.to_matrix3d(width as f32);
+
+    matrix3d_to_object(matrix3d, activation)
+}
+
 fn sync_from_display_object<'gc>(
     activation: &mut Activation<'_, 'gc>,
     this: Object<'gc>,

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

@@ -211,7 +211,7 @@ pub fn color_transform_to_object<'gc>(
     Ok(object)
 }
 
-fn matrix3d_to_object<'gc>(
+pub fn matrix3d_to_object<'gc>(
     matrix: Matrix3D,
     activation: &mut Activation<'_, 'gc>,
 ) -> Result<Value<'gc>, Error<'gc>> {

render/src/perspective_projection.rs

@@ -1,3 +1,7 @@
+use std::f64::consts::PI;
+
+use crate::matrix3d::Matrix3D;
+
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct PerspectiveProjection {
     /// Unit: degree. Must be greater than 0 and less than 180.
@@ -15,3 +19,48 @@ impl Default for PerspectiveProjection {
         }
     }
 }
+
+impl PerspectiveProjection {
+    const DEG2RAD: f64 = PI / 180.0;
+
+    pub fn from_focal_length(focal_length: f64, width: f64) -> Self {
+        Self {
+            field_of_view: f64::atan((width / 2.0) / focal_length) / Self::DEG2RAD * 2.0,
+            ..Default::default()
+        }
+    }
+
+    pub fn focal_length(&self, width: f32) -> f32 {
+        let rad = self.field_of_view * Self::DEG2RAD;
+        (width / 2.0) * f64::tan((PI - rad) / 2.0) as f32
+    }
+
+    pub fn to_matrix3d(&self, width: f32) -> Matrix3D {
+        let focal_length = self.focal_length(width) as f64;
+
+        Matrix3D {
+            raw_data: [
+                //
+                focal_length,
+                0.0,
+                0.0,
+                0.0,
+                //
+                0.0,
+                focal_length,
+                0.0,
+                0.0,
+                //
+                0.0,
+                0.0,
+                1.0,
+                1.0,
+                //
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+            ],
+        }
+    }
+}