Move double-sided mesh support into separate OutlineFace component.

Author: komadori

examples/ui_mode.rs

@@ -267,10 +267,14 @@ fn change_mode(
             commands
                 .entity(entity)
                 .insert(match event.entered.unwrap() {
-                    DrawMethod::Extrude => OutlineMode::ExtrudeFlat,
-                    DrawMethod::ExtrudeDoubleSided => OutlineMode::ExtrudeFlatDoubleSided,
-                    DrawMethod::JumpFlood => OutlineMode::FloodFlat,
-                    DrawMethod::JumpFloodDoubleSided => OutlineMode::FloodFlatDoubleSided,
+                    DrawMethod::Extrude => (OutlineMode::ExtrudeFlat, OutlineFace::Front),
+                    DrawMethod::ExtrudeDoubleSided => {
+                        (OutlineMode::ExtrudeFlat, OutlineFace::DoubleSided)
+                    }
+                    DrawMethod::JumpFlood => (OutlineMode::FloodFlat, OutlineFace::Front),
+                    DrawMethod::JumpFloodDoubleSided => {
+                        (OutlineMode::FloodFlat, OutlineFace::DoubleSided)
+                    }
                 });
         }
     }

src/computed.rs

@@ -3,8 +3,8 @@ use bevy::{camera::visibility::RenderLayers, ecs::query::QueryItem, prelude::*};
 use crate::{
     pipeline_key::ComputedOutlineKey,
     uniforms::{DepthMode, DrawMode},
-    InheritOutline, OutlineAlphaMask, OutlineMode, OutlinePlaneDepth, OutlineRenderLayers,
-    OutlineStencil, OutlineStencilEnabled, OutlineVolume, OutlineWarmUp,
+    InheritOutline, OutlineAlphaMask, OutlineFace, OutlineMode, OutlinePlaneDepth,
+    OutlineRenderLayers, OutlineStencil, OutlineStencilEnabled, OutlineVolume, OutlineWarmUp,
 };
 
 #[derive(Clone)]
@@ -24,6 +24,10 @@ pub(crate) struct ComputedStencil {
 pub(crate) struct ComputedMode {
     pub(crate) depth_mode: DepthMode,
     pub(crate) draw_mode: DrawMode,
+}
+
+#[derive(Clone)]
+pub(crate) struct ComputedFace {
     pub(crate) double_sided: bool,
 }
 
@@ -124,6 +128,7 @@ pub(crate) struct ComputedInternal {
     pub(crate) volume: Sourced<ComputedVolume>,
     pub(crate) stencil: Sourced<ComputedStencil>,
     pub(crate) mode: Sourced<ComputedMode>,
+    pub(crate) face: Sourced<ComputedFace>,
     pub(crate) depth: Sourced<ComputedDepth>,
     pub(crate) layers: Sourced<RenderLayers>,
     pub(crate) alpha_mask: Sourced<OutlineAlphaMask>,
@@ -141,6 +146,7 @@ type OutlineComponents<'a> = (
     Option<Ref<'a, OutlineVolume>>,
     Option<Ref<'a, OutlineStencil>>,
     Option<Ref<'a, OutlineMode>>,
+    Option<Ref<'a, OutlineFace>>,
     Option<Ref<'a, OutlinePlaneDepth>>,
     Option<Ref<'a, OutlineRenderLayers>>,
     Option<Ref<'a, RenderLayers>>,
@@ -220,6 +226,7 @@ fn update_computed_outline(
         volume,
         stencil,
         mode,
+        face,
         depth,
         layers,
         fallback_layers,
@@ -239,6 +246,7 @@ fn update_computed_outline(
                 || computed.volume.is_changed(&volume, has_parent)
                 || computed.stencil.is_changed(&stencil, has_parent)
                 || computed.mode.is_changed(&mode, has_parent)
+                || computed.face.is_changed(&face, has_parent)
                 || computed.depth.is_changed(&depth, has_parent)
                 || computed
                     .layers
@@ -279,32 +287,25 @@ fn update_computed_outline(
                     OutlineMode::ExtrudeFlat => ComputedMode {
                         depth_mode: DepthMode::Flat,
                         draw_mode: DrawMode::Extrude,
-                        double_sided: false,
-                    },
-                    OutlineMode::ExtrudeFlatDoubleSided => ComputedMode {
-                        depth_mode: DepthMode::Flat,
-                        draw_mode: DrawMode::Extrude,
-                        double_sided: true,
                     },
                     OutlineMode::ExtrudeReal => ComputedMode {
                         depth_mode: DepthMode::Real,
                         draw_mode: DrawMode::Extrude,
-                        double_sided: false,
                     },
                     #[cfg(feature = "flood")]
                     OutlineMode::FloodFlat => ComputedMode {
                         depth_mode: DepthMode::Flat,
                         draw_mode: DrawMode::JumpFlood,
-                        double_sided: false,
-                    },
-                    #[cfg(feature = "flood")]
-                    OutlineMode::FloodFlatDoubleSided => ComputedMode {
-                        depth_mode: DepthMode::Flat,
-                        draw_mode: DrawMode::JumpFlood,
-                        double_sided: true,
                     },
                 },
             ),
+            face: Sourced::set(
+                face,
+                parent_computed.map(|p| p.face.value.clone()),
+                |face| ComputedFace {
+                    double_sided: matches!(face, OutlineFace::DoubleSided),
+                },
+            ),
             depth: Sourced::set(
                 depth,
                 parent_computed.map(|p| p.depth.value.clone()),

src/lib.rs

@@ -268,16 +268,24 @@ pub enum OutlineMode {
     /// Vertex extrusion flattened into a billboard. (default)
     #[default]
     ExtrudeFlat,
-    /// Vertex extrusion flattened into a double-sided billboard.
-    ExtrudeFlatDoubleSided,
     /// Vertex extrusion in real model-space.
     ExtrudeReal,
     // Jump-flood into a billboard.
     #[cfg(feature = "flood")]
     FloodFlat,
-    // Jump-flood into a double-sided billboard.
-    #[cfg(feature = "flood")]
-    FloodFlatDoubleSided,
+}
+
+/// A component which controls which faces of an outline are rendered.
+#[derive(Clone, Component, Default)]
+#[cfg_attr(feature = "reflect", derive(Reflect))]
+#[cfg_attr(feature = "reflect", reflect(Component, Default))]
+#[non_exhaustive]
+pub enum OutlineFace {
+    /// Render only the front face of the outline. (default)
+    #[default]
+    Front,
+    /// Render both the front and back faces of the outline.
+    DoubleSided,
 }
 
 /// A component which controls the depth sorting of flat outlines and stencils.
@@ -553,6 +561,7 @@ impl Plugin for OutlinePlugin {
             .register_type::<OutlineVolume>()
             .register_type::<OutlineRenderLayers>()
             .register_type::<OutlineMode>()
+            .register_type::<OutlineFace>()
             .register_type::<OutlineAlphaMask>()
             .register_type::<InheritOutline>()
             .register_type::<OutlineMsaa>();

src/pipeline.rs

@@ -155,6 +155,9 @@ impl SpecializedMeshPipeline for OutlinePipeline {
             vertex_defs.push(val.clone());
             fragment_defs.push(val);
         };
+        if key.depth_mode() == DepthMode::Real && key.double_sided() {
+            warn!("OutlineFace::DoubleSided is incompatible with OutlineMode::ExtrudeReal");
+        }
         let cull_mode = match (key.pass_type(), key.depth_mode()) {
             (PassType::Stencil, DepthMode::Real) => Some(Face::Back),
             (PassType::Volume, DepthMode::Real) => Some(Face::Front),

src/pipeline_key.rs

@@ -293,7 +293,7 @@ pub(crate) fn compute_outline_key(
             .with_vertex_offset_zero(outline.volume.value.offset == 0.0)
             .with_stencil_vertex_offset_zero(outline.stencil.value.offset == 0.0)
             .with_plane_offset_zero(outline.depth.value.world_plane_offset == Vec3::ZERO)
-            .with_double_sided(outline.mode.value.double_sided)
+            .with_double_sided(outline.face.value.double_sided)
             .with_alpha_mask_texture(outline.alpha_mask.value.texture.is_some())
             .with_alpha_mask_channel(outline.alpha_mask.value.channel);
     }