core: Use HasPrefixField for DisplayObjectBase casts

...and add a new `TDisplayObjectObject::gc_base` method that can be used
to provide `base(_mut)` default impls.

Because DO structs are now `repr(C)`, also reorder fields in rough order
of decreasing alignment to avoid adding extra padding.

Author: moulins

core/src/display_object.rs

@@ -14,7 +14,8 @@ use crate::tag_utils::SwfMovie;
 use crate::types::{Degrees, Percent};
 use crate::vminterface::Instantiator;
 use bitflags::bitflags;
-use gc_arena::{Collect, Mutation};
+use gc_arena::lock::RefLock;
+use gc_arena::{Collect, Gc, Mutation};
 use ruffle_macros::{enum_trait_object, istr};
 use ruffle_render::perspective_projection::PerspectiveProjection;
 use ruffle_render::pixel_bender::PixelBenderShaderHandle;
@@ -1111,8 +1112,19 @@ pub fn apply_standard_mask_and_scroll<'gc, F>(
 pub trait TDisplayObject<'gc>:
     'gc + Clone + Copy + Collect<'gc> + Debug + Into<DisplayObject<'gc>>
 {
-    fn base<'a>(&'a self) -> Ref<'a, DisplayObjectBase<'gc>>;
-    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>>;
+    fn gc_base(self) -> Gc<'gc, RefLock<DisplayObjectBase<'gc>>>;
+
+    #[no_dynamic]
+    #[inline(always)]
+    fn base<'a>(&'a self) -> Ref<'a, DisplayObjectBase<'gc>> {
+        self.gc_base().borrow()
+    }
+
+    #[no_dynamic]
+    #[inline(always)]
+    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>> {
+        self.gc_base().borrow_mut(mc)
+    }
 
     /// The `SCALE_ROTATION_CACHED` flag should only be set in SWFv5+.
     /// So scaling/rotation values always have to get recalculated from the matrix in SWFv4.

core/src/display_object/avm1_button.rs

@@ -16,7 +16,7 @@ use crate::tag_utils::{SwfMovie, SwfSlice};
 use crate::utils::HasPrefixField;
 use crate::vminterface::Instantiator;
 use core::fmt;
-use gc_arena::barrier::{field, unlock};
+use gc_arena::barrier::unlock;
 use gc_arena::lock::{Lock, RefLock};
 use gc_arena::{Collect, Gc, Mutation};
 use ruffle_macros::istr;
@@ -247,13 +247,8 @@ impl<'gc> Avm1Button<'gc> {
 }
 
 impl<'gc> TDisplayObject<'gc> for Avm1Button<'gc> {
-    fn base(&self) -> Ref<'_, DisplayObjectBase<'gc>> {
-        self.0.base.base()
-    }
-
-    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>> {
-        let base = field!(Gc::write(mc, self.0), Avm1ButtonData, base);
-        InteractiveObjectBase::base_mut(base)
+    fn gc_base(self) -> Gc<'gc, RefLock<DisplayObjectBase<'gc>>> {
+        HasPrefixField::as_prefix_gc(self.raw_interactive())
     }
 
     fn instantiate(self, mc: &Mutation<'gc>) -> DisplayObject<'gc> {
@@ -447,11 +442,7 @@ impl<'gc> TInteractiveObject<'gc> for Avm1Button<'gc> {
 
         // The `keyPress` event doesn't fire if the button is inside another button.
         if matches!(event, ClipEvent::KeyPress { .. })
-            && self
-                .base()
-                .parent
-                .and_then(|p| p.as_avm1_button())
-                .is_some()
+            && self.parent().and_then(|p| p.as_avm1_button()).is_some()
         {
             return ClipEventResult::NotHandled;
         }
@@ -623,7 +614,7 @@ impl<'gc> Avm1ButtonData<'gc> {
         condition: ButtonActionCondition,
     ) -> ClipEventResult {
         let mut handled = ClipEventResult::NotHandled;
-        if let Some(parent) = self.base.base().parent {
+        if let Some(parent) = self.base.base.borrow().parent {
             for action in &self.shared.actions {
                 if action.conditions.matches(condition) {
                     // Note that AVM1 buttons run actions relative to their parent, not themselves.

core/src/display_object/avm2_button.rs

@@ -22,11 +22,11 @@ use crate::tag_utils::{SwfMovie, SwfSlice};
 use crate::utils::HasPrefixField;
 use crate::vminterface::Instantiator;
 use core::fmt;
-use gc_arena::barrier::{field, unlock};
-use gc_arena::lock::Lock;
+use gc_arena::barrier::unlock;
+use gc_arena::lock::{Lock, RefLock};
 use gc_arena::{Collect, Gc, Mutation};
 use ruffle_render::filters::Filter;
-use std::cell::{Cell, Ref, RefCell, RefMut};
+use std::cell::{Cell, RefCell};
 use std::sync::Arc;
 
 #[derive(Clone, Collect, Copy)]
@@ -413,13 +413,8 @@ impl<'gc> Avm2Button<'gc> {
 }
 
 impl<'gc> TDisplayObject<'gc> for Avm2Button<'gc> {
-    fn base(&self) -> Ref<'_, DisplayObjectBase<'gc>> {
-        self.0.base.base()
-    }
-
-    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>> {
-        let base = field!(Gc::write(mc, self.0), Avm2ButtonData, base);
-        InteractiveObjectBase::base_mut(base)
+    fn gc_base(self) -> Gc<'gc, RefLock<DisplayObjectBase<'gc>>> {
+        HasPrefixField::as_prefix_gc(self.raw_interactive())
     }
 
     fn instantiate(self, mc: &Mutation<'gc>) -> DisplayObject<'gc> {

core/src/display_object/bitmap.rs

@@ -11,14 +11,15 @@ use crate::context::{RenderContext, UpdateContext};
 use crate::display_object::{DisplayObjectBase, DisplayObjectPtr, DisplayObjectWeak};
 use crate::prelude::*;
 use crate::tag_utils::SwfMovie;
+use crate::utils::HasPrefixField;
 use crate::vminterface::Instantiator;
 use core::fmt;
 use gc_arena::barrier::unlock;
 use gc_arena::lock::{Lock, RefLock};
 use gc_arena::{Collect, Gc, GcCell, GcWeak, Mutation};
 use ruffle_render::backend::RenderBackend;
 use ruffle_render::bitmap::{BitmapFormat, PixelSnapping};
-use std::cell::{Cell, Ref, RefMut};
+use std::cell::Cell;
 use std::sync::Arc;
 
 #[derive(Clone, Debug, Collect, Copy)]
@@ -96,13 +97,22 @@ impl fmt::Debug for Bitmap<'_> {
     }
 }
 
-#[derive(Clone, Collect)]
+#[derive(Clone, Collect, HasPrefixField)]
 #[collect(no_drop)]
+#[repr(C, align(8))]
 pub struct BitmapGraphicData<'gc> {
     base: RefLock<DisplayObjectBase<'gc>>,
-    id: CharacterId,
     movie: Arc<SwfMovie>,
 
+    /// The AVM2 side of this object.
+    ///
+    /// AVM1 code cannot directly reference `Bitmap`s, so this does not support
+    /// storing an AVM1 object.
+    avm2_object: Lock<Option<Avm2Object<'gc>>>,
+
+    /// The class associated with this Bitmap.
+    avm2_bitmap_class: Lock<BitmapClass<'gc>>,
+
     /// The current bitmap data object.
     bitmap_data: Lock<BitmapDataWrapper<'gc>>,
 
@@ -112,20 +122,13 @@ pub struct BitmapGraphicData<'gc> {
     width: Cell<u32>,
     height: Cell<u32>,
 
+    id: CharacterId,
+
     /// Whether or not bitmap smoothing is enabled.
     smoothing: Cell<bool>,
 
     /// How to snap this bitmap to the pixel grid
     pixel_snapping: Cell<PixelSnapping>,
-
-    /// The AVM2 side of this object.
-    ///
-    /// AVM1 code cannot directly reference `Bitmap`s, so this does not support
-    /// storing an AVM1 object.
-    avm2_object: Lock<Option<Avm2Object<'gc>>>,
-
-    /// The class associated with this Bitmap.
-    avm2_bitmap_class: Lock<BitmapClass<'gc>>,
 }
 
 impl<'gc> Bitmap<'gc> {
@@ -301,12 +304,8 @@ impl<'gc> Bitmap<'gc> {
 }
 
 impl<'gc> TDisplayObject<'gc> for Bitmap<'gc> {
-    fn base(&self) -> Ref<'_, DisplayObjectBase<'gc>> {
-        self.0.base.borrow()
-    }
-
-    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>> {
-        unlock!(Gc::write(mc, self.0), BitmapGraphicData, base).borrow_mut()
+    fn gc_base(self) -> Gc<'gc, RefLock<DisplayObjectBase<'gc>>> {
+        HasPrefixField::as_prefix_gc(self.0)
     }
 
     fn instantiate(self, gc_context: &Mutation<'gc>) -> DisplayObject<'gc> {

core/src/display_object/edit_text.rs

@@ -33,8 +33,9 @@ use crate::vminterface::{AvmObject, Instantiator};
 use chrono::DateTime;
 use chrono::Utc;
 use core::fmt;
-use gc_arena::barrier::{field, unlock};
-use gc_arena::{Collect, Gc, Lock, Mutation, RefLock};
+use gc_arena::barrier::unlock;
+use gc_arena::lock::{Lock, RefLock};
+use gc_arena::{Collect, Gc, Mutation};
 use ruffle_macros::istr;
 use ruffle_render::commands::Command as RenderCommand;
 use ruffle_render::commands::CommandHandler;
@@ -2501,13 +2502,8 @@ impl<'gc> EditText<'gc> {
 }
 
 impl<'gc> TDisplayObject<'gc> for EditText<'gc> {
-    fn base(&self) -> Ref<'_, DisplayObjectBase<'gc>> {
-        self.0.base.base()
-    }
-
-    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>> {
-        let base = field!(Gc::write(mc, self.0), EditTextData, base);
-        InteractiveObjectBase::base_mut(base)
+    fn gc_base(self) -> Gc<'gc, RefLock<DisplayObjectBase<'gc>>> {
+        HasPrefixField::as_prefix_gc(self.raw_interactive())
     }
 
     fn instantiate(self, gc_context: &Mutation<'gc>) -> DisplayObject<'gc> {

core/src/display_object/graphic.rs

@@ -9,13 +9,15 @@ use crate::drawing::Drawing;
 use crate::library::MovieLibrarySource;
 use crate::prelude::*;
 use crate::tag_utils::SwfMovie;
+use crate::utils::HasPrefixField;
 use crate::vminterface::Instantiator;
 use core::fmt;
 use gc_arena::barrier::unlock;
-use gc_arena::{Collect, Gc, Lock, Mutation, RefLock};
+use gc_arena::lock::{Lock, RefLock};
+use gc_arena::{Collect, Gc, Mutation};
 use ruffle_render::backend::ShapeHandle;
 use ruffle_render::commands::CommandHandler;
-use std::cell::{OnceCell, Ref, RefCell, RefMut};
+use std::cell::{OnceCell, RefCell, RefMut};
 use std::sync::Arc;
 
 #[derive(Clone, Collect, Copy)]
@@ -30,8 +32,9 @@ impl fmt::Debug for Graphic<'_> {
     }
 }
 
-#[derive(Clone, Collect)]
+#[derive(Clone, Collect, HasPrefixField)]
 #[collect(no_drop)]
+#[repr(C, align(8))]
 pub struct GraphicData<'gc> {
     base: RefLock<DisplayObjectBase<'gc>>,
     shared: Lock<Gc<'gc, GraphicShared>>,
@@ -65,7 +68,7 @@ impl<'gc> Graphic<'gc> {
         Graphic(Gc::new(
             context.gc(),
             GraphicData {
-                base: RefLock::new(Default::default()),
+                base: Default::default(),
                 shared: Lock::new(Gc::new(context.gc(), shared)),
                 class: Lock::new(None),
                 avm2_object: Lock::new(None),
@@ -121,12 +124,8 @@ impl<'gc> Graphic<'gc> {
 }
 
 impl<'gc> TDisplayObject<'gc> for Graphic<'gc> {
-    fn base(&self) -> Ref<'_, DisplayObjectBase<'gc>> {
-        self.0.base.borrow()
-    }
-
-    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>> {
-        unlock!(Gc::write(mc, self.0), GraphicData, base).borrow_mut()
+    fn gc_base(self) -> Gc<'gc, RefLock<DisplayObjectBase<'gc>>> {
+        HasPrefixField::as_prefix_gc(self.0)
     }
 
     fn instantiate(self, gc_context: &Mutation<'gc>) -> DisplayObject<'gc> {

core/src/display_object/interactive.rs

@@ -18,12 +18,13 @@ use crate::display_object::{
 };
 use crate::events::{ClipEvent, ClipEventResult, MouseButton};
 use crate::string::AvmString;
+use crate::utils::HasPrefixField;
 use bitflags::bitflags;
-use gc_arena::barrier::{unlock, Write};
+use gc_arena::barrier::unlock;
 use gc_arena::lock::{Lock, RefLock};
 use gc_arena::{Collect, Gc, Mutation};
 use ruffle_macros::{enum_trait_object, istr};
-use std::cell::{Cell, Ref, RefMut};
+use std::cell::Cell;
 use std::fmt::Debug;
 use swf::{Point, Rectangle, Twips};
 
@@ -81,19 +82,22 @@ bitflags! {
     }
 }
 
-#[derive(Collect, Clone)]
+#[derive(Collect, Clone, HasPrefixField)]
 #[collect(no_drop)]
+#[repr(C, align(8))]
 pub struct InteractiveObjectBase<'gc> {
     pub base: RefLock<DisplayObjectBase<'gc>>,
-    #[collect(require_static)]
-    flags: Cell<InteractiveObjectFlags>,
+
     context_menu: Lock<Avm2Value<'gc>>,
 
     #[collect(require_static)]
-    tab_enabled: Cell<Option<bool>>,
+    tab_index: Cell<Option<i32>>,
 
     #[collect(require_static)]
-    tab_index: Cell<Option<i32>>,
+    flags: Cell<InteractiveObjectFlags>,
+
+    #[collect(require_static)]
+    tab_enabled: Cell<Option<bool>>,
 
     /// Specifies whether this object displays a yellow rectangle when focused.
     focus_rect: Cell<Option<bool>>,
@@ -113,14 +117,6 @@ impl Default for InteractiveObjectBase<'_> {
 }
 
 impl<'gc> InteractiveObjectBase<'gc> {
-    pub fn base(&self) -> Ref<'_, DisplayObjectBase<'gc>> {
-        self.base.borrow()
-    }
-
-    pub fn base_mut(this: &Write<Self>) -> RefMut<'_, DisplayObjectBase<'gc>> {
-        unlock!(this, Self, base).borrow_mut()
-    }
-
     fn contains_flag(&self, flag: InteractiveObjectFlags) -> bool {
         self.flags.get().contains(flag)
     }

core/src/display_object/loader_display.rs

@@ -13,7 +13,7 @@ use crate::display_object::interactive::InteractiveObjectBase;
 use crate::tag_utils::SwfMovie;
 use crate::utils::HasPrefixField;
 use core::fmt;
-use gc_arena::barrier::{field, unlock};
+use gc_arena::barrier::unlock;
 use gc_arena::lock::{Lock, RefLock};
 use gc_arena::{Collect, Gc, GcWeak, Mutation};
 use std::cell::{Ref, RefMut};
@@ -66,13 +66,8 @@ impl<'gc> LoaderDisplay<'gc> {
 }
 
 impl<'gc> TDisplayObject<'gc> for LoaderDisplay<'gc> {
-    fn base(&self) -> Ref<'_, DisplayObjectBase<'gc>> {
-        self.0.base.base()
-    }
-
-    fn base_mut<'a>(&'a self, mc: &Mutation<'gc>) -> RefMut<'a, DisplayObjectBase<'gc>> {
-        let base = field!(Gc::write(mc, self.0), LoaderDisplayData, base);
-        InteractiveObjectBase::base_mut(base)
+    fn gc_base(self) -> Gc<'gc, RefLock<DisplayObjectBase<'gc>>> {
+        HasPrefixField::as_prefix_gc(self.raw_interactive())
     }
 
     fn instantiate(self, gc_context: &Mutation<'gc>) -> DisplayObject<'gc> {