Merge branch 'master' of github.com:komadori/bevy_mod_outline into stencil-control

Author: komadori

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## bevy_mod_outline 0.10.3 (2025-08-24)
+
+### Added
+- Added OutlineWarmUp for warming up pipelines.
+
 ## bevy_mod_outline 0.10.2 (2025-06-19)
 
 ### Fixed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mod_outline"
-version = "0.10.2"
+version = "0.10.3"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "A mesh outlining plugin for Bevy."

src/computed.rs

@@ -1,9 +1,10 @@
 use bevy::{ecs::query::QueryItem, prelude::*, render::view::RenderLayers};
 
 use crate::{
+    pipeline_key::ComputedOutlineKey,
     uniforms::{DepthMode, DrawMode},
     InheritOutline, OutlineAlphaMask, OutlineMode, OutlinePlaneDepth, OutlineRenderLayers,
-    OutlineStencil, OutlineStencilEnabled, OutlineVolume, TextureChannel,
+    OutlineStencil, OutlineStencilEnabled, OutlineVolume, OutlineWarmUp,
 };
 
 #[derive(Clone)]
@@ -117,13 +118,6 @@ impl<T: Clone> Sourced<T> {
     }
 }
 
-#[derive(Clone)]
-pub(crate) struct ComputedAlphaMask {
-    pub(crate) texture: Option<Handle<Image>>,
-    pub(crate) channel: TextureChannel,
-    pub(crate) threshold: f32,
-}
-
 #[derive(Clone)]
 pub(crate) struct ComputedInternal {
     pub(crate) inherited_from: Option<Entity>,
@@ -132,11 +126,13 @@ pub(crate) struct ComputedInternal {
     pub(crate) mode: Sourced<ComputedMode>,
     pub(crate) depth: Sourced<ComputedDepth>,
     pub(crate) layers: Sourced<RenderLayers>,
-    pub(crate) alpha_mask: Sourced<ComputedAlphaMask>,
+    pub(crate) alpha_mask: Sourced<OutlineAlphaMask>,
+    pub(crate) warm_up: Sourced<OutlineWarmUp>,
 }
 
 /// A component for storing the computed depth at which the outline lies.
 #[derive(Clone, Component, Default)]
+#[require(ComputedOutlineKey)]
 pub struct ComputedOutline(pub(crate) Option<ComputedInternal>);
 
 type OutlineComponents<'a> = (
@@ -149,6 +145,7 @@ type OutlineComponents<'a> = (
     Option<Ref<'a, OutlineRenderLayers>>,
     Option<Ref<'a, RenderLayers>>,
     Option<Ref<'a, OutlineAlphaMask>>,
+    Option<Ref<'a, OutlineWarmUp>>,
 );
 
 #[allow(clippy::type_complexity)]
@@ -217,10 +214,18 @@ fn propagate_computed_outline(
 
 fn update_computed_outline(
     computed: &mut Mut<'_, ComputedOutline>,
-    (visibility, transform, volume, stencil, mode, depth, layers, fallback_layers, alpha_mask): QueryItem<
-        '_,
-        OutlineComponents,
-    >,
+    (
+        visibility,
+        transform,
+        volume,
+        stencil,
+        mode,
+        depth,
+        layers,
+        fallback_layers,
+        alpha_mask,
+        warm_up,
+    ): QueryItem<'_, OutlineComponents>,
     parent_computed: Option<&ComputedInternal>,
     parent_entity: Option<Entity>,
     force_update: bool,
@@ -326,11 +331,12 @@ fn update_computed_outline(
             alpha_mask: Sourced::set(
                 alpha_mask,
                 parent_computed.map(|p| p.alpha_mask.value.clone()),
-                |mask| ComputedAlphaMask {
-                    texture: mask.texture.clone(),
-                    channel: mask.channel,
-                    threshold: mask.threshold,
-                },
+                |mask| mask.clone(),
+            ),
+            warm_up: Sourced::set(
+                warm_up,
+                parent_computed.map(|p| p.warm_up.value.clone()),
+                |warm_up| warm_up.clone(),
             ),
         });
     }

src/flood/compose_output.rs

@@ -15,14 +15,13 @@ use bevy::{
         view::{ExtractedView, ViewDepthTexture, ViewTarget},
     },
 };
-use bitfield::{bitfield_bitrange, bitfield_fields};
 use wgpu_types::{
     BlendState, ColorTargetState, ColorWrites, CompareFunction, DepthBiasState, DepthStencilState,
     MultisampleState, PrimitiveState, SamplerBindingType, ShaderStages, StencilState,
     TextureFormat, TextureSampleType,
 };
 
-use crate::uniforms::ExtractedOutline;
+use crate::{pipeline_key::ViewPipelineKey, uniforms::ExtractedOutline};
 
 use super::{DrawMode, OutlineViewUniform, COMPOSE_OUTPUT_SHADER_HANDLE};
 
@@ -47,47 +46,11 @@ pub(crate) fn prepare_compose_output_uniform(
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct ComposeOutputPipelineKey(u32);
-bitfield_bitrange! {struct ComposeOutputPipelineKey(u32)}
-
-impl ComposeOutputPipelineKey {
-    bitfield_fields! {
-        u32;
-        msaa_samples_minus_one, set_msaa_samples_minus_one: 5, 0;
-        pub hdr_format, set_hdr_format: 6;
-    }
-
-    pub(crate) fn new() -> Self {
-        ComposeOutputPipelineKey(0)
-    }
-
-    pub(crate) fn with_msaa(mut self, msaa: Msaa) -> Self {
-        self.set_msaa_samples_minus_one(msaa as u32 - 1);
-        self
-    }
-
-    pub(crate) fn msaa(&self) -> Msaa {
-        match self.msaa_samples_minus_one() + 1 {
-            x if x == Msaa::Off as u32 => Msaa::Off,
-            x if x == Msaa::Sample2 as u32 => Msaa::Sample2,
-            x if x == Msaa::Sample4 as u32 => Msaa::Sample4,
-            x if x == Msaa::Sample8 as u32 => Msaa::Sample8,
-            x => panic!("Invalid value for Msaa: {}", x),
-        }
-    }
-
-    pub(crate) fn with_hdr_format(mut self, hdr_format: bool) -> Self {
-        self.set_hdr_format(hdr_format);
-        self
-    }
-}
-
 #[derive(Clone, Resource)]
 pub(crate) struct ComposeOutputPipeline {
     pub(crate) layout: BindGroupLayout,
     pub(crate) sampler: Sampler,
-    pub(crate) pipeline_cache: HashMap<ComposeOutputPipelineKey, CachedRenderPipelineId>,
+    pub(crate) pipeline_cache: HashMap<ViewPipelineKey, CachedRenderPipelineId>,
 }
 
 impl FromWorld for ComposeOutputPipeline {
@@ -121,7 +84,7 @@ impl ComposeOutputPipeline {
     pub(crate) fn get_pipeline(
         &mut self,
         pipeline_cache: &PipelineCache,
-        key: ComposeOutputPipelineKey,
+        key: ViewPipelineKey,
     ) -> CachedRenderPipelineId {
         *self.pipeline_cache.entry(key).or_insert_with(|| {
             pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
@@ -176,7 +139,7 @@ pub(crate) fn prepare_compose_output_pass(
     for (entity, view, msaa) in query.iter() {
         let pipeline_id = compose_output_pipeline.get_pipeline(
             &pipeline_cache,
-            ComposeOutputPipelineKey::new()
+            ViewPipelineKey::new()
                 .with_msaa(*msaa)
                 .with_hdr_format(view.hdr),
         );

src/flood/flood_init.rs

@@ -3,10 +3,7 @@ use std::ops::Range;
 use bevy::prelude::*;
 use bevy::render::camera::{ExtractedCamera, Viewport};
 use bevy::render::mesh::allocator::MeshAllocator;
-use bevy::render::mesh::RenderMesh;
-use bevy::render::render_asset::RenderAssets;
 use bevy::render::render_phase::{DrawFunctions, PhaseItemExtraIndex, ViewSortedRenderPhases};
-use bevy::render::render_resource::{PipelineCache, SpecializedMeshPipelines};
 use bevy::render::sync_world::MainEntity;
 use bevy::render::view::{ExtractedView, RenderLayers};
 use bevy::render::{
@@ -19,15 +16,13 @@ use bevy::render::{
 };
 use wgpu_types::ImageSubresourceRange;
 
-use crate::queue::OutlineRangefinder;
+use crate::queue::{OutlineCache, OutlineCacheEntry, OutlineRangefinder};
 use crate::uniforms::ExtractedOutline;
 use crate::view_uniforms::OutlineQueueStatus;
 
 use super::bounds::FloodMeshBounds;
 use super::node::FloodOutline;
-use super::{
-    DepthMode, DrawMode, DrawOutline, OutlinePipeline, OutlineViewUniform, PassType, PipelineKey,
-};
+use super::{DrawMode, DrawOutline, OutlineViewUniform};
 
 pub(crate) fn prepare_flood_phases(
     query: Query<&ExtractedView, With<OutlineViewUniform>>,
@@ -41,11 +36,8 @@ pub(crate) fn prepare_flood_phases(
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn queue_flood_meshes(
     flood_draw_functions: Res<DrawFunctions<FloodOutline>>,
-    outline_pipeline: Res<OutlinePipeline>,
-    mut pipelines: ResMut<SpecializedMeshPipelines<OutlinePipeline>>,
-    pipeline_cache: Res<PipelineCache>,
-    render_meshes: Res<RenderAssets<RenderMesh>>,
     mesh_allocator: Res<MeshAllocator>,
+    outline_cache: Res<OutlineCache>,
     material_meshes: Query<(Entity, &MainEntity, &ExtractedOutline, &FloodMeshBounds)>,
     mut flood_phases: ResMut<ViewSortedRenderPhases<FloodOutline>>,
     mut views: Query<(
@@ -78,6 +70,11 @@ pub(crate) fn queue_flood_meshes(
 
         let rangefinder = OutlineRangefinder::new(view);
 
+        let outline_view_cache = outline_cache
+            .view_map
+            .get(&view.retained_view_entity)
+            .unwrap();
+
         for (entity, main_entity, outline, mesh_bounds) in material_meshes.iter() {
             if !outline.volume {
                 continue;
@@ -91,10 +88,6 @@ pub(crate) fn queue_flood_meshes(
                 continue;
             }
 
-            let Some(mesh) = render_meshes.get(outline.mesh_id) else {
-                continue;
-            };
-
             // Calculate screen-space bounds of outline
             let border = (view_uniform.scale_physical_from_logical
                 * outline.instance_data.volume_offset)
@@ -107,36 +100,30 @@ pub(crate) fn queue_flood_meshes(
 
             let (_vertex_slab, index_slab) = mesh_allocator.mesh_slabs(&outline.mesh_id);
 
-            let flood_key = PipelineKey::new()
-                .with_primitive_topology(mesh.primitive_topology())
-                .with_depth_mode(DepthMode::Flat)
-                .with_morph_targets(mesh.morph_targets.is_some())
-                .with_vertex_offset_zero(true)
-                .with_plane_offset_zero(true)
-                .with_pass_type(PassType::FloodInit)
-                .with_double_sided(outline.double_sided)
-                .with_alpha_mask_texture(outline.alpha_mask_id.is_some())
-                .with_alpha_mask_channel(outline.alpha_mask_channel);
+            let Some(OutlineCacheEntry {
+                changed_tick: _,
+                stencil_pipeline_id: _,
+                volume_pipeline_id,
+            }) = outline_view_cache.entity_map.get(main_entity)
+            else {
+                continue;
+            };
 
             queue_status.has_volume = true;
 
-            if let Ok(pipeline) =
-                pipelines.specialize(&pipeline_cache, &outline_pipeline, flood_key, &mesh.layout)
-            {
-                flood_phase.add(FloodOutline {
-                    distance: rangefinder.distance_of(outline),
-                    entity,
-                    main_entity: *main_entity,
-                    pipeline,
-                    draw_function: draw_flood,
-                    batch_range: 0..0,
-                    extra_index: PhaseItemExtraIndex::None,
-                    indexed: index_slab.is_some(),
-                    volume_offset: outline.instance_data.volume_offset,
-                    volume_colour: outline.instance_data.volume_colour,
-                    screen_space_bounds,
-                });
-            }
+            flood_phase.add(FloodOutline {
+                distance: rangefinder.distance_of(outline),
+                entity,
+                main_entity: *main_entity,
+                pipeline: *volume_pipeline_id,
+                draw_function: draw_flood,
+                batch_range: 0..0,
+                extra_index: PhaseItemExtraIndex::None,
+                indexed: index_slab.is_some(),
+                volume_offset: outline.instance_data.volume_offset,
+                volume_colour: outline.instance_data.volume_colour,
+                screen_space_bounds,
+            });
         }
     }
 }

src/flood/mod.rs

@@ -28,9 +28,9 @@ use flood_init::{prepare_flood_phases, queue_flood_meshes};
 use jump_flood::JumpFloodPipeline;
 use node::{FloodNode, FloodOutline};
 
-use crate::pipeline::{OutlinePipeline, PassType, PipelineKey};
+use crate::pipeline::OutlinePipeline;
 use crate::render::DrawOutline;
-use crate::uniforms::{DepthMode, DrawMode};
+use crate::uniforms::DrawMode;
 use crate::view_uniforms::OutlineViewUniform;
 use crate::{add_dummy_phase_buffer, NodeOutline};