avm2: Implement setStencilReferenceValue and setStencilActions on flash.display3D.Context3D

SuchAFuriousDeath · SuchAFuriousDeath · commit 4fee76e74e4b · 2025-07-15T13:45:34.000+02:00
diff --git a/core/src/avm2/globals/flash/display3D/Context3D.as b/core/src/avm2/globals/flash/display3D/Context3D.as
@@ -69,23 +69,19 @@ package flash.display3D {
             return 2048;
         }
 
-        public function setStencilReferenceValue(referenceValue:uint, readMask:uint = 255, writeMask:uint = 255):void {
-            stub_method("flash.display3D.Context3D", "setStencilReferenceValue");
-        }
+        public native function setStencilReferenceValue(referenceValue:uint, readMask:uint = 255, writeMask:uint = 255):void;
 
         public native function setSamplerStateAt(sampler:int, wrap:String, filter:String, mipfilter:String):void;
 
         public native function setRenderToTexture(texture:TextureBase, enableDepthAndStencil:Boolean = false, antiAlias:int = 0, surfaceSelector:int = 0, colorOutputIndex:int = 0):void;
 
-        public function setStencilActions(
+        public native function setStencilActions(
             triangleFace:String = "frontAndBack",
             compareMode:String = "always",
             actionOnBothPass:String = "keep",
             actionOnDepthFail:String = "keep",
             actionOnDepthPassStencilFail:String = "keep"
-        ):void {
-            stub_method("flash.display3D.Context3D", "setStencilActions");
-        }
+        ):void;
 
         public native function dispose(recreate:Boolean = true):void;
     }
diff --git a/core/src/avm2/globals/flash/display3D/context_3d.rs b/core/src/avm2/globals/flash/display3D/context_3d.rs
@@ -9,12 +9,12 @@ use crate::avm2::TObject;
 use crate::avm2::Value;
 use crate::avm2_stub_method;
 use ruffle_macros::istr;
-use ruffle_render::backend::Context3DWrapMode;
 use ruffle_render::backend::{
     BufferUsage, Context3DBlendFactor, Context3DCompareMode, Context3DTextureFormat,
     Context3DTriangleFace, Context3DVertexBufferFormat, ProgramType,
 };
 use ruffle_render::backend::{Context3DProfile, Context3DTextureFilter};
+use ruffle_render::backend::{Context3DStencilAction, Context3DWrapMode};
 use swf::{Rectangle, Twips};
 
 pub fn create_index_buffer<'gc>(
@@ -686,6 +686,59 @@ pub fn set_render_to_texture<'gc>(
     Ok(Value::Undefined)
 }
 
+pub fn set_stencil_actions<'gc>(
+    activation: &mut Activation<'_, 'gc>,
+    this: Value<'gc>,
+    args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error<'gc>> {
+    let this = this.as_object().unwrap();
+
+    if let Some(context) = this.as_context_3d() {
+        let triangle_face = args.get_string_non_null(activation, 0, "triangleFace")?;
+
+        let culling = if &*triangle_face == b"none" {
+            Context3DTriangleFace::None
+        } else if &*triangle_face == b"back" {
+            Context3DTriangleFace::Back
+        } else if &*triangle_face == b"front" {
+            Context3DTriangleFace::Front
+        } else if &*triangle_face == b"frontAndBack" {
+            Context3DTriangleFace::FrontAndBack
+        } else {
+            tracing::error!("Unknown culling {:?}", triangle_face);
+            Context3DTriangleFace::None
+        };
+
+        let compare_mode = args.get_string_non_null(activation, 1, "compareMode")?;
+        let compare_mode = Context3DCompareMode::from_wstr(&compare_mode)
+            .ok_or_else(|| make_error_2008(activation, "compareMode"))?;
+
+        let action_on_both_pass = args.get_string_non_null(activation, 2, "actionOnBothPass")?;
+        let action_on_both_pass = Context3DStencilAction::from_wstr(&action_on_both_pass)
+            .ok_or_else(|| make_error_2008(activation, "actionOnBothPass"))?;
+
+        let action_on_depth_fail = args.get_string_non_null(activation, 3, "actionOnDepthFail")?;
+        let action_on_depth_fail = Context3DStencilAction::from_wstr(&action_on_depth_fail)
+            .ok_or_else(|| make_error_2008(activation, "actionOnDepthFail"))?;
+
+        let action_on_depth_pass_stencil_fail =
+            args.get_string_non_null(activation, 4, "actionOnDepthPassStencilFail")?;
+        let action_on_depth_pass_stencil_fail =
+            Context3DStencilAction::from_wstr(&action_on_depth_pass_stencil_fail)
+                .ok_or_else(|| make_error_2008(activation, "actionOnDepthPassStencilFail"))?;
+
+        context.set_stencil_actions(
+            culling,
+            compare_mode,
+            action_on_both_pass,
+            action_on_depth_fail,
+            action_on_depth_pass_stencil_fail,
+        );
+    }
+
+    Ok(Value::Undefined)
+}
+
 pub fn set_render_to_back_buffer<'gc>(
     _activation: &mut Activation<'_, 'gc>,
     this: Value<'gc>,
@@ -697,6 +750,23 @@ pub fn set_render_to_back_buffer<'gc>(
     context.set_render_to_back_buffer();
     Ok(Value::Undefined)
 }
+pub fn set_stencil_reference_value<'gc>(
+    activation: &mut Activation<'_, 'gc>,
+    this: Value<'gc>,
+    args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error<'gc>> {
+    let this = this.as_object().unwrap();
+
+    if let Some(context) = this.as_context_3d() {
+        let reference_value = args.get_u32(activation, 0)?;
+        let read_mask = args.get_u32(activation, 1)?;
+        let write_mask = args.get_u32(activation, 2)?;
+
+        context.set_stencil_reference_value(reference_value, read_mask, write_mask);
+    }
+
+    Ok(Value::Undefined)
+}
 
 pub fn set_sampler_state_at<'gc>(
     activation: &mut Activation<'_, 'gc>,
diff --git a/core/src/avm2/object/context3d_object.rs b/core/src/avm2/object/context3d_object.rs
@@ -12,8 +12,8 @@ use crate::utils::HasPrefixField;
 use gc_arena::{Collect, Gc, GcCell, GcWeak};
 use ruffle_render::backend::{
     BufferUsage, Context3D, Context3DBlendFactor, Context3DCommand, Context3DCompareMode,
-    Context3DTextureFormat, Context3DTriangleFace, Context3DVertexBufferFormat, ProgramType,
-    Texture,
+    Context3DStencilAction, Context3DTextureFormat, Context3DTriangleFace,
+    Context3DVertexBufferFormat, ProgramType, Texture,
 };
 use ruffle_render::commands::CommandHandler;
 use std::cell::Cell;
@@ -476,6 +476,40 @@ impl<'gc> Context3DObject<'gc> {
             ctx.process_command(Context3DCommand::SetScissorRectangle { rect })
         });
     }
+
+    pub(crate) fn set_stencil_actions(
+        &self,
+        triangle_face: Context3DTriangleFace,
+        compare_mode: Context3DCompareMode,
+        action_on_both_pass: Context3DStencilAction,
+        action_on_depth_fail: Context3DStencilAction,
+        action_on_depth_pass_stencil_fail: Context3DStencilAction,
+    ) {
+        self.with_context_3d(|ctx| {
+            ctx.process_command(Context3DCommand::SetStencilActions {
+                triangle_face,
+                compare_mode,
+                action_on_both_pass,
+                action_on_depth_fail,
+                action_on_depth_pass_stencil_fail,
+            })
+        });
+    }
+
+    pub(crate) fn set_stencil_reference_value(
+        &self,
+        reference_value: u32,
+        read_mask: u32,
+        write_mask: u32,
+    ) {
+        self.with_context_3d(|ctx| {
+            ctx.process_command(Context3DCommand::SetStencilReferenceValue {
+                reference_value,
+                read_mask,
+                write_mask,
+            })
+        });
+    }
 }
 
 #[derive(Collect, HasPrefixField)]
diff --git a/render/src/backend.rs b/render/src/backend.rs
@@ -362,6 +362,74 @@ impl Context3DCompareMode {
     }
 }
 
+#[cfg(feature = "wgpu")]
+impl From<Context3DCompareMode> for wgpu::CompareFunction {
+    fn from(mode: Context3DCompareMode) -> Self {
+        match mode {
+            Context3DCompareMode::Never => wgpu::CompareFunction::Never,
+            Context3DCompareMode::Less => wgpu::CompareFunction::Less,
+            Context3DCompareMode::Equal => wgpu::CompareFunction::Equal,
+            Context3DCompareMode::LessEqual => wgpu::CompareFunction::LessEqual,
+            Context3DCompareMode::Greater => wgpu::CompareFunction::Greater,
+            Context3DCompareMode::NotEqual => wgpu::CompareFunction::NotEqual,
+            Context3DCompareMode::GreaterEqual => wgpu::CompareFunction::GreaterEqual,
+            Context3DCompareMode::Always => wgpu::CompareFunction::Always,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Context3DStencilAction {
+    DecrementSaturate,
+    DecrementWrap,
+    IncrementSaturate,
+    IncrementWrap,
+    Invert,
+    Keep,
+    Set,
+    Zero,
+}
+
+impl Context3DStencilAction {
+    pub fn from_wstr(s: &WStr) -> Option<Self> {
+        if s == b"decrementSaturate" {
+            Some(Context3DStencilAction::DecrementSaturate)
+        } else if s == b"decrementWrap" {
+            Some(Context3DStencilAction::DecrementWrap)
+        } else if s == b"incrementSaturate" {
+            Some(Context3DStencilAction::IncrementSaturate)
+        } else if s == b"incrementWrap" {
+            Some(Context3DStencilAction::IncrementWrap)
+        } else if s == b"invert" {
+            Some(Context3DStencilAction::Invert)
+        } else if s == b"keep" {
+            Some(Context3DStencilAction::Keep)
+        } else if s == b"set" {
+            Some(Context3DStencilAction::Set)
+        } else if s == b"zero" {
+            Some(Context3DStencilAction::Zero)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(feature = "wgpu")]
+impl From<Context3DStencilAction> for wgpu::StencilOperation {
+    fn from(action: Context3DStencilAction) -> Self {
+        match action {
+            Context3DStencilAction::DecrementSaturate => wgpu::StencilOperation::DecrementClamp,
+            Context3DStencilAction::DecrementWrap => wgpu::StencilOperation::DecrementWrap,
+            Context3DStencilAction::IncrementSaturate => wgpu::StencilOperation::IncrementClamp,
+            Context3DStencilAction::IncrementWrap => wgpu::StencilOperation::IncrementWrap,
+            Context3DStencilAction::Invert => wgpu::StencilOperation::Invert,
+            Context3DStencilAction::Keep => wgpu::StencilOperation::Keep,
+            Context3DStencilAction::Set => wgpu::StencilOperation::Replace,
+            Context3DStencilAction::Zero => wgpu::StencilOperation::Zero,
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug)]
 pub enum Context3DWrapMode {
     Clamp,
@@ -517,6 +585,18 @@ pub enum Context3DCommand<'a> {
     SetScissorRectangle {
         rect: Option<Rectangle<Twips>>,
     },
+    SetStencilActions {
+        triangle_face: Context3DTriangleFace,
+        compare_mode: Context3DCompareMode,
+        action_on_both_pass: Context3DStencilAction,
+        action_on_depth_fail: Context3DStencilAction,
+        action_on_depth_pass_stencil_fail: Context3DStencilAction,
+    },
+    SetStencilReferenceValue {
+        reference_value: u32,
+        read_mask: u32,
+        write_mask: u32,
+    },
 }
 
 #[derive(Clone, Debug)]
diff --git a/render/wgpu/src/context3d/current_pipeline.rs b/render/wgpu/src/context3d/current_pipeline.rs
diff --git a/render/wgpu/src/context3d/mod.rs b/render/wgpu/src/context3d/mod.rs
