Add IfVolume stencil enable state for inheritance.

Author: komadori

src/computed.rs

@@ -3,7 +3,7 @@ use bevy::{ecs::query::QueryItem, prelude::*, render::view::RenderLayers};
 use crate::{
     uniforms::{DepthMode, DrawMode},
     InheritOutline, OutlineAlphaMask, OutlineMode, OutlinePlaneDepth, OutlineRenderLayers,
-    OutlineStencil, OutlineVolume, TextureChannel,
+    OutlineStencil, OutlineStencilEnabled, OutlineVolume, TextureChannel,
 };
 
 #[derive(Clone)]
@@ -15,7 +15,7 @@ pub(crate) struct ComputedVolume {
 
 #[derive(Clone)]
 pub(crate) struct ComputedStencil {
-    pub(crate) enabled: bool,
+    pub(crate) enabled: OutlineStencilEnabled,
     pub(crate) offset: f32,
 }
 
@@ -52,12 +52,22 @@ impl<T: Clone> Sourced<T> {
         inherit: Option<T>,
         f: impl FnOnce(&U) -> T,
     ) -> Self {
-        Self::set_with_fallback::<U, U>(value, None, inherit, f)
+        Self::set_with_fallback::<U, U>(value, None, &U::default(), inherit, f)
     }
 
-    pub fn set_with_fallback<U: Default, V: Clone + Into<U>>(
+    pub fn set_with_default<U: Clone + Default>(
+        value: Option<Ref<U>>,
+        default: &U,
+        inherit: Option<T>,
+        f: impl FnOnce(&U) -> T,
+    ) -> Self {
+        Self::set_with_fallback::<U, U>(value, None, default, inherit, f)
+    }
+
+    pub fn set_with_fallback<U, V: Clone + Into<U>>(
         value: Option<Ref<U>>,
         fallback: Option<Ref<V>>,
+        default: &U,
         inherit: Option<T>,
         f: impl FnOnce(&U) -> T,
     ) -> Self {
@@ -78,7 +88,7 @@ impl<T: Clone> Sourced<T> {
             }
         } else {
             Sourced {
-                value: f(&U::default()),
+                value: f(default),
                 source: Source::Default,
             }
         }
@@ -244,11 +254,16 @@ fn update_computed_outline(
                     colour: vol.colour.into(),
                 },
             ),
-            stencil: Sourced::set(
+            stencil: Sourced::set_with_default(
                 stencil,
+                &OutlineStencil::INHERIT_DEFAULT,
                 parent_computed.map(|p| p.stencil.value.clone()),
                 |sten| ComputedStencil {
-                    enabled: visibility.get() && sten.enabled,
+                    enabled: if visibility.get() {
+                        sten.enabled
+                    } else {
+                        OutlineStencilEnabled::Never
+                    },
                     offset: sten.offset,
                 },
             ),
@@ -304,6 +319,7 @@ fn update_computed_outline(
             layers: Sourced::set_with_fallback(
                 layers,
                 fallback_layers,
+                &default(),
                 parent_computed.map(|p| p.layers.value.clone()),
                 |layers| layers.0.clone(),
             ),
@@ -354,7 +370,10 @@ mod tests {
             .0
             .as_ref()
             .expect("ComputedOutline should have Some value after update");
-        assert!(internal.stencil.value.enabled);
+        assert_eq!(
+            internal.stencil.value.enabled,
+            OutlineStencilEnabled::IfVolume
+        );
         assert!(!internal.volume.value.enabled);
 
         // Update the system again and check that nothing has changed

src/lib.rs

@@ -121,37 +121,69 @@ pub enum NodeOutline {
     EndOutlinePasses,
 }
 
+/// Specifies when a stencil should be rendered.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "reflect", derive(Reflect))]
+#[cfg_attr(feature = "reflect", reflect(Default))]
+pub enum OutlineStencilEnabled {
+    /// Always render a stencil
+    #[default]
+    Always,
+    /// Only render a stencil if the volume is visible
+    IfVolume,
+    /// Never render a stencil
+    Never,
+}
+
+impl OutlineStencilEnabled {
+    pub(crate) fn is_enabled(&self, volume_enabled: bool) -> bool {
+        match self {
+            OutlineStencilEnabled::Always => true,
+            OutlineStencilEnabled::IfVolume => volume_enabled,
+            OutlineStencilEnabled::Never => false,
+        }
+    }
+}
+
 /// A component for stenciling meshes during outline rendering.
 ///
 /// Stencils are used both to prevent entities with outlines from being
 /// covered by their own outline volumes and to allow entities to occlude
 /// any outlines behind them.
-#[derive(Clone, Component)]
+#[derive(Clone, Component, Default)]
 #[cfg_attr(feature = "reflect", derive(Reflect))]
 #[cfg_attr(feature = "reflect", reflect(Component, Default))]
 pub struct OutlineStencil {
-    /// Enable rendering of the stencil
-    pub enabled: bool,
+    /// Controls when the stencil should be rendered
+    pub enabled: OutlineStencilEnabled,
     /// Offset of the stencil in logical pixels
     pub offset: f32,
 }
 
-impl Default for OutlineStencil {
-    fn default() -> Self {
-        OutlineStencil {
-            enabled: true,
-            offset: 0.0,
-        }
-    }
+impl OutlineStencil {
+    pub(crate) const INHERIT_DEFAULT: OutlineStencil = OutlineStencil {
+        enabled: OutlineStencilEnabled::IfVolume,
+        offset: 0.0,
+    };
 }
 
-fn lerp_bool(this: bool, other: bool, scalar: f32) -> bool {
+fn lerp_stencil_enabled(
+    this: OutlineStencilEnabled,
+    other: OutlineStencilEnabled,
+    scalar: f32,
+) -> OutlineStencilEnabled {
     if scalar <= 0.0 {
         this
     } else if scalar >= 1.0 {
         other
     } else {
-        this | other
+        match (this, other) {
+            (OutlineStencilEnabled::Always, _) => OutlineStencilEnabled::Always,
+            (_, OutlineStencilEnabled::Always) => OutlineStencilEnabled::Always,
+            (OutlineStencilEnabled::IfVolume, _) => OutlineStencilEnabled::IfVolume,
+            (_, OutlineStencilEnabled::IfVolume) => OutlineStencilEnabled::Never,
+            _ => OutlineStencilEnabled::Never,
+        }
     }
 }
 
@@ -176,7 +208,7 @@ macro_rules! impl_lerp {
 
 fn lerp_stencil(start: &OutlineStencil, end: &OutlineStencil, t: f32) -> OutlineStencil {
     OutlineStencil {
-        enabled: lerp_bool(start.enabled, end.enabled, t),
+        enabled: lerp_stencil_enabled(start.enabled, end.enabled, t),
         offset: start.offset.lerp(end.offset, t),
     }
 }
@@ -196,6 +228,16 @@ pub struct OutlineVolume {
     pub colour: Color,
 }
 
+fn lerp_bool(this: bool, other: bool, t: f32) -> bool {
+    if t <= 0.0 {
+        this
+    } else if t >= 1.0 {
+        other
+    } else {
+        this || other
+    }
+}
+
 fn lerp_volume(start: &OutlineVolume, end: &OutlineVolume, t: f32) -> OutlineVolume {
     OutlineVolume {
         visible: lerp_bool(start.visible, end.visible, t),

src/uniforms.rs

@@ -99,7 +99,13 @@ pub(crate) fn set_outline_visibility(
 ) {
     for (entity, mut visibility, computed) in query.iter_mut() {
         if let ComputedOutline(Some(computed)) = computed {
-            if computed.volume.value.enabled || computed.stencil.value.enabled {
+            if computed.volume.value.enabled
+                || computed
+                    .stencil
+                    .value
+                    .enabled
+                    .is_enabled(computed.volume.value.enabled)
+            {
                 visibility.set();
                 previous_visible.remove(&entity);
             }
@@ -130,7 +136,11 @@ pub(crate) fn extract_outlines(
             continue;
         };
         let extracted_outline = ExtractedOutline {
-            stencil: computed.stencil.value.enabled,
+            stencil: computed
+                .stencil
+                .value
+                .enabled
+                .is_enabled(computed.volume.value.enabled),
             volume: computed.volume.value.enabled,
             depth_mode: computed.mode.value.depth_mode,
             draw_mode: computed.mode.value.draw_mode,