core: Allow `Bitmap`s to hold an AVM2 representation

core/src/avm2/globals.rs

@@ -118,6 +118,7 @@ pub struct SystemPrototypes<'gc> {
     pub vector: Object<'gc>,
     pub soundtransform: Object<'gc>,
     pub soundchannel: Object<'gc>,
+    pub bitmap: Object<'gc>,
 }
 
 impl<'gc> SystemPrototypes<'gc> {
@@ -170,6 +171,7 @@ impl<'gc> SystemPrototypes<'gc> {
             vector: empty,
             soundtransform: empty,
             soundchannel: empty,
+            bitmap: empty,
         }
     }
 }
@@ -213,6 +215,7 @@ pub struct SystemClasses<'gc> {
     pub vector: Object<'gc>,
     pub soundtransform: Object<'gc>,
     pub soundchannel: Object<'gc>,
+    pub bitmap: Object<'gc>,
 }
 
 impl<'gc> SystemClasses<'gc> {
@@ -265,6 +268,7 @@ impl<'gc> SystemClasses<'gc> {
             vector: empty,
             soundtransform: empty,
             soundchannel: empty,
+            bitmap: empty,
         }
     }
 }
@@ -791,6 +795,13 @@ pub fn load_player_globals<'gc>(
         domain,
         script,
     )?;
+    avm2_system_class!(
+        bitmap,
+        activation,
+        flash::display::bitmap::create_class(mc),
+        domain,
+        script
+    );
 
     // package `flash.geom`
     avm2_system_class!(

core/src/avm2/globals/flash/display.rs

@@ -1,6 +1,7 @@
 //! `flash.display` namespace
 
 pub mod actionscriptversion;
+pub mod bitmap;
 pub mod capsstyle;
 pub mod displayobject;
 pub mod displayobjectcontainer;

core/src/avm2/globals/flash/display/bitmap.rs

@@ -0,0 +1,49 @@
+//! `flash.display.Bitmap` builtin/prototype
+
+use crate::avm2::activation::Activation;
+use crate::avm2::class::{Class, ClassAttributes};
+use crate::avm2::method::Method;
+use crate::avm2::names::{Namespace, QName};
+use crate::avm2::object::Object;
+use crate::avm2::value::Value;
+use crate::avm2::Error;
+use gc_arena::{GcCell, MutationContext};
+
+/// Implements `flash.display.Bitmap`'s instance constructor.
+pub fn instance_init<'gc>(
+    activation: &mut Activation<'_, 'gc, '_>,
+    this: Option<Object<'gc>>,
+    _args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error> {
+    if let Some(this) = this {
+        activation.super_init(this, &[])?;
+    }
+
+    Ok(Value::Undefined)
+}
+
+/// Implements `flash.display.Bitmap`'s class constructor.
+pub fn class_init<'gc>(
+    _activation: &mut Activation<'_, 'gc, '_>,
+    _this: Option<Object<'gc>>,
+    _args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error> {
+    Ok(Value::Undefined)
+}
+
+/// Construct `Bitmap`'s class.
+pub fn create_class<'gc>(mc: MutationContext<'gc, '_>) -> GcCell<'gc, Class<'gc>> {
+    let class = Class::new(
+        QName::new(Namespace::package("flash.media"), "Bitmap"),
+        Some(QName::new(Namespace::package("flash.media"), "DisplayObject").into()),
+        Method::from_builtin(instance_init, "<Bitmap instance initializer>", mc),
+        Method::from_builtin(class_init, "<Bitmap class initializer>", mc),
+        mc,
+    );
+
+    let mut write = class.write(mc);
+
+    write.set_attributes(ClassAttributes::SEALED);
+
+    class
+}

core/src/display_object/bitmap.rs

@@ -1,6 +1,10 @@
 //! Bitmap display object
 
 use crate::avm1;
+use crate::avm2::{
+    Activation as Avm2Activation, Object as Avm2Object, StageObject as Avm2StageObject,
+    Value as Avm2Value,
+};
 use crate::backend::render::BitmapHandle;
 use crate::context::{RenderContext, UpdateContext};
 use crate::display_object::{DisplayObjectBase, TDisplayObject};
@@ -27,6 +31,7 @@ pub struct BitmapData<'gc> {
     static_data: Gc<'gc, BitmapStatic>,
     bitmap_data: Option<GcCell<'gc, crate::bitmap::bitmap_data::BitmapData>>,
     smoothing: bool,
+    avm2_object: Option<Avm2Object<'gc>>,
 }
 
 impl<'gc> Bitmap<'gc> {
@@ -54,6 +59,7 @@ impl<'gc> Bitmap<'gc> {
                 ),
                 bitmap_data,
                 smoothing,
+                avm2_object: None,
             },
         ))
     }
@@ -111,6 +117,19 @@ impl<'gc> TDisplayObject<'gc> for Bitmap<'gc> {
             context
                 .avm1
                 .add_to_exec_list(context.gc_context, (*self).into());
+        } else if self.avm_type() == AvmType::Avm2 {
+            let mut activation = Avm2Activation::from_nothing(context.reborrow());
+            let bitmap = activation.avm2().classes().bitmap;
+            match Avm2StageObject::for_display_object_childless(
+                &mut activation,
+                (*self).into(),
+                bitmap,
+            ) {
+                Ok(object) => {
+                    self.0.write(activation.context.gc_context).avm2_object = Some(object.into())
+                }
+                Err(e) => log::error!("Got error when creating AVM2 side of bitmap: {}", e),
+            }
         }
 
         if run_frame {
@@ -147,6 +166,14 @@ impl<'gc> TDisplayObject<'gc> for Bitmap<'gc> {
             bitmap_data.smoothing,
         );
     }
+
+    fn object2(&self) -> Avm2Value<'gc> {
+        self.0
+            .read()
+            .avm2_object
+            .map(|o| o.into())
+            .unwrap_or(Avm2Value::Undefined)
+    }
 }
 
 /// Static data shared between all instances of a bitmap.