feat: add Raycast Method option for MaskingShape component

This option allows you to set raycast determination that differs from the masking method.

close #262

Author: mob-sakai

Packages/src/Editor/MaskingShapeEditor.cs

@@ -12,6 +12,7 @@ public class MaskingShapeEditor : Editor
         private SerializedProperty _maskingMethod;
         private SerializedProperty _showMaskGraphic;
         private SerializedProperty _softnessRange;
+        private SerializedProperty _raycastMethod;
 
         protected void OnEnable()
         {
@@ -20,6 +21,7 @@ protected void OnEnable()
             _alphaHitTest = serializedObject.FindProperty("m_AlphaHitTest");
             _antiAliasingThreshold = serializedObject.FindProperty("m_AntiAliasingThreshold");
             _softnessRange = serializedObject.FindProperty("m_SoftnessRange");
+            _raycastMethod = serializedObject.FindProperty("m_RaycastMethod");
         }
 
         public override void OnInspectorGUI()
@@ -52,6 +54,7 @@ public override void OnInspectorGUI()
                     break;
             }
 
+            EditorGUILayout.PropertyField(_raycastMethod);
             serializedObject.ApplyModifiedProperties();
 
             // Draw alpha hit test warning

Packages/src/README.md

@@ -346,6 +346,11 @@ scene or prefab.
     - ⚠️ Enable this only if necessary, as it will require more graphics memory and processing time.
 - **Softness Range** (SoftMasking only): Override the softness range of the parent `SoftMask` component.
 - **Anti Aliasing Threshold** (AntiAliasing only): Override the anti-alias threshold of the parent `SoftMask` component.
+- **Raycast Method**:
+    - `Auto (Default)`: Same behavior as before. A mode similar to `Masking Method` is selected.
+    - `Additive`: When the pointer is within this shape, the raycast is enabled.
+    - `Subtract`: When the pointer is within this shape, the raycast is disabled.
+    - `Ignore`: This shape is ignored in raycast determination.
 
 `MaskingShape` component allows you to add or remove the masking region.  
 Placing `MaskingShape` component (with any `Graphic`) under `SoftMask` component.  

Packages/src/Runtime/MaskingShape/MaskingShape.cs

@@ -22,6 +22,14 @@ public enum MaskingMethod
             Subtract
         }
 
+        public enum RaycastMethod
+        {
+            Auto,
+            Additive,
+            Subtract,
+            Ignore
+        }
+
         [Tooltip("Masking method.")]
         [SerializeField]
         private MaskingMethod m_MaskingMethod = MaskingMethod.Additive;
@@ -47,6 +55,10 @@ public enum MaskingMethod
         [SerializeField]
         private MinMax01 m_SoftnessRange = new MinMax01(0, 1f);
 
+        [Tooltip("Method to determine whether this masking shape should be a raycast target.")]
+        [SerializeField]
+        private RaycastMethod m_RaycastMethod = RaycastMethod.Auto;
+
         private bool _antiAliasingRegistered;
         private MaskingShapeContainer _container;
         private Graphic _graphic;
@@ -136,6 +148,30 @@ public MinMax01 softnessRange
             }
         }
 
+        /// <summary>
+        /// Method to determine whether this masking shape should be a raycast target.
+        /// </summary>
+        public RaycastMethod raycastMethod
+        {
+            get => parent != null ? parent.raycastMethod : m_RaycastMethod;
+            set => m_RaycastMethod = value;
+        }
+
+        /// <summary>
+        /// Method to determine whether this masking shape should be a raycast target.
+        /// </summary>
+        public RaycastMethod actualRaycastMethod
+        {
+            get
+            {
+                return raycastMethod != RaycastMethod.Auto
+                    ? raycastMethod
+                    : maskingMethod == MaskingMethod.Additive
+                        ? RaycastMethod.Additive
+                        : RaycastMethod.Subtract;
+            }
+        }
+
         protected override void OnEnable()
         {
             UpdateContainer();

Packages/src/Runtime/MaskingShape/MaskingShapeContainer.cs

@@ -106,17 +106,16 @@ public bool IsInside(Vector2 sp, Camera eventCamera, bool defaultValid = false,
             valid = defaultValid;
             for (var i = 0; i < m_MaskingShapes.Count; i++)
             {
-                if (!m_MaskingShapes[i] || !m_MaskingShapes[i].IsInside(sp, eventCamera, threshold)) continue;
-                switch (m_MaskingShapes[i].maskingMethod)
+                var maskingShape = m_MaskingShapes[i];
+                if (!maskingShape || !maskingShape.IsInside(sp, eventCamera, threshold)) continue;
+                switch (maskingShape.actualRaycastMethod)
                 {
-                    case MaskingShape.MaskingMethod.Additive:
+                    case MaskingShape.RaycastMethod.Additive:
                         valid = true;
                         break;
-                    case MaskingShape.MaskingMethod.Subtract:
+                    case MaskingShape.RaycastMethod.Subtract:
                         valid = false;
                         break;
-                    default:
-                        throw new ArgumentOutOfRangeException();
                 }
             }
 

Packages/src/Runtime/SoftMask.cs

@@ -116,6 +116,8 @@ public enum MaskingMode
 
         public MaskingShape.MaskingMethod maskingMethod => MaskingShape.MaskingMethod.Additive;
 
+        public MaskingShape.RaycastMethod raycastMethod => MaskingShape.RaycastMethod.Additive;
+
         /// <summary>
         /// Masking mode.<br />
         /// <b>SoftMasking</b>: Use RenderTexture as a soft mask buffer. The alpha of the masking graphic can be used.<br />

Packages/src/Runtime/Utilities/ISoftMasking.cs

@@ -5,33 +5,38 @@ namespace Coffee.UISoftMask
 {
     public interface ISoftMasking : IMeshModifier
     {
-        public bool enabled { get; }
+        bool enabled { get; }
 
-        public MaskingShape.MaskingMethod maskingMethod { get; }
+        MaskingShape.MaskingMethod maskingMethod { get; }
 
         /// <summary>
         /// Show the graphic that is associated with the Mask render area.
         /// </summary>
-        public bool showMaskGraphic { get; }
+        bool showMaskGraphic { get; }
 
         /// <summary>
         /// The transparent part of the mask cannot be clicked.
         /// This can be achieved by enabling Read/Write enabled in the Texture Import Settings for the texture.
         /// <para></para>
         /// NOTE: Enable this only if necessary, as it will require more graphics memory and processing time.
         /// </summary>
-        public bool alphaHitTest { get; }
+        bool alphaHitTest { get; }
 
         /// <summary>
         /// Threshold for anti-alias masking.
         /// The smaller this value, the less jagged it is.
         /// </summary>
-        public float antiAliasingThreshold { get; }
+        float antiAliasingThreshold { get; }
 
         /// <summary>
         /// The minimum and maximum alpha values used for soft masking.
         /// The larger the gap between these values, the stronger the softness effect.
         /// </summary>
-        public MinMax01 softnessRange { get; }
+        MinMax01 softnessRange { get; }
+
+        /// <summary>
+        /// Method to determine whether this masking shape should be a raycast target.
+        /// </summary>
+        MaskingShape.RaycastMethod raycastMethod { get; }
     }
 }