Port to Bevy 0.17.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mod_outline"
-version = "0.10.3"
+version = "0.11.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "A mesh outlining plugin for Bevy."
@@ -11,7 +11,7 @@ keywords = ["gamedev", "bevy", "outline"]
 categories = ["game-engines", "rendering"]
 
 [dependencies]
-bevy = { version = "0.16.0", default-features = false, features = [
+bevy = { version = "0.17.0-rc.1", default-features = false, features = [
     "std",
     "async_executor",
     "bevy_log",
@@ -23,7 +23,7 @@ bitfield = "0.15"
 interpolation = { version = "0.3", optional = true }
 thiserror = "1.0"
 nonmax = "0.5"
-wgpu-types = "24"
+wgpu-types = "26"
 itertools = { version = "0.14", optional = true }
 
 [features]
@@ -33,24 +33,28 @@ reflect = []
 scene = ["bevy/bevy_scene"]
 
 [dev-dependencies]
-bevy = { version = "0.16.0", default-features = false, features = [
+bevy = { version = "0.17.0-rc.1", default-features = false, features = [
     "animation",
+    "bevy_anti_alias",
     "bevy_gltf",
     "bevy_mesh_picking_backend",
     "bevy_pbr",
+    "bevy_post_process",
     "bevy_sprite",
     "bevy_state",
     "bevy_text",
     "bevy_ui",
+    "bevy_ui_render",
     "bevy_window",
     "bevy_winit",
     "default_font",
+    "reflect_auto_register",
     "png",
     "x11",
     "ktx2",
     "smaa_luts",
     "tonemapping_luts",
-    "zstd",
+    "zstd_rust",
 ] }
 
 [[example]]

README.md

@@ -12,7 +12,7 @@ vertex extrusion and jump flood methods.
 
 ```toml
 [dependencies]
-bevy_mod_outline = "0.10"
+bevy_mod_outline = "0.11"
 ```
 
 ## Examples
@@ -96,6 +96,7 @@ cargo run --example picking
 
 | This Version | Bevy version |
 |--------------|--------------|
+| 0.11.x       | 0.17.x       |
 | 0.10.x       | 0.16.x       |
 | 0.9.x        | 0.15.x       |
 | 0.8.x        | 0.14.x       |

examples/alpha_mask.rs

@@ -1,5 +1,4 @@
-use bevy::prelude::*;
-use bevy::render::render_asset::RenderAssetUsages;
+use bevy::{asset::RenderAssetUsages, prelude::*};
 use bevy_mod_outline::*;
 use std::f32::consts::TAU;
 

examples/bloom.rs

@@ -1,8 +1,9 @@
 use std::f32::consts::{PI, TAU};
 
 use bevy::{
-    core_pipeline::bloom::{Bloom, BloomCompositeMode},
+    post_process::bloom::{Bloom, BloomCompositeMode},
     prelude::*,
+    render::view::Hdr,
 };
 
 use bevy_mod_outline::*;
@@ -69,11 +70,8 @@ fn setup(
     // Add HDR camera
     commands.spawn((
         Camera3d::default(),
-        Camera {
-            hdr: true,
-            ..default()
-        },
         Transform::from_xyz(0.0, 3.0, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
+        Hdr,
         Msaa::Sample4,
         Bloom {
             intensity: 1.0,

examples/picking.rs

@@ -90,7 +90,7 @@ fn setup(
 
 /// Observer system that manages what pickable objects are selected
 fn on_click(
-    mut event: Trigger<Pointer<Click>>,
+    mut event: On<Pointer<Click>>,
     mut commands: Commands,
     mut query: Query<(Entity, &mut OutlineVolume, Option<&Selected>)>,
     keys: Res<ButtonInput<KeyCode>>,
@@ -122,7 +122,7 @@ fn on_click(
     }
 
     // Select a mesh
-    if let Ok((entity, mut outline, selected)) = query.get_mut(event.target) {
+    if let Ok((entity, mut outline, selected)) = query.get_mut(event.entity) {
         if let Ok(mut entity) = commands.get_entity(entity) {
             // When selecting multiple objects, allow clicking a selected object to deselect it.
             if multi_select && selected.is_some() {

examples/render_layers.rs

@@ -1,8 +1,8 @@
 use std::f32::consts::PI;
 
 use bevy::{
+    camera::{visibility::RenderLayers, Viewport},
     prelude::*,
-    render::{camera::Viewport, view::RenderLayers},
     window::PrimaryWindow,
 };
 use bevy_mod_outline::{OutlinePlugin, OutlineRenderLayers, OutlineVolume};

examples/ui_aa.rs

@@ -1,8 +1,8 @@
 use bevy::{
-    core_pipeline::{
-        experimental::taa::{TemporalAntiAliasPlugin, TemporalAntiAliasing},
+    anti_alias::{
         fxaa::Fxaa,
         smaa::{Smaa, SmaaPreset},
+        taa::TemporalAntiAliasing,
     },
     prelude::*,
 };
@@ -13,7 +13,7 @@ use bevy_mod_outline::*;
 fn main() {
     App::new()
         .insert_resource(ClearColor(Color::BLACK))
-        .add_plugins((DefaultPlugins, TemporalAntiAliasPlugin, OutlinePlugin))
+        .add_plugins((DefaultPlugins, OutlinePlugin))
         .insert_state(AAMode::NoAA)
         .add_systems(Startup, setup)
         .add_systems(Update, (bounce, highlight, interaction))
@@ -142,7 +142,7 @@ fn setup(
                             align_items: AlignItems::Center,
                             ..default()
                         },
-                        BorderColor(Color::BLACK),
+                        BorderColor::all(Color::BLACK),
                         BorderRadius::MAX,
                         BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
                         mode,
@@ -182,9 +182,9 @@ fn bounce(mut query: Query<&mut Transform, With<Bounce>>, timer: Res<Time>, mut
 fn highlight(mut query: Query<(&mut BorderColor, &AAMode)>, state: Res<State<AAMode>>) {
     for (mut border, m) in query.iter_mut() {
         *border = if m == state.get() {
-            BorderColor(Color::srgb(0.0, 0.0, 1.0))
+            BorderColor::all(Color::srgb(0.0, 0.0, 1.0))
         } else {
-            BorderColor(Color::BLACK)
+            BorderColor::all(Color::BLACK)
         };
     }
 }

examples/ui_mode.rs

@@ -213,7 +213,7 @@ fn create_buttons<T: Component + States>(builder: &mut ChildSpawnerCommands, val
                             align_items: AlignItems::Center,
                             ..default()
                         },
-                        BorderColor(Color::BLACK),
+                        BorderColor::all(Color::BLACK),
                         BorderRadius::MAX,
                         BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
                         value.clone(),
@@ -233,9 +233,9 @@ fn highlight<T: Component + States>(
 ) {
     for (mut border, m) in query.iter_mut() {
         *border = if m == state.get() {
-            BorderColor(Color::srgb(0.0, 0.0, 1.0))
+            BorderColor::all(Color::srgb(0.0, 0.0, 1.0))
         } else {
-            BorderColor(Color::BLACK)
+            BorderColor::all(Color::BLACK)
         };
     }
 }
@@ -259,7 +259,7 @@ fn interaction<T: Component + FreelyMutableState>(
 
 fn change_mode(
     mut commands: Commands,
-    mut reader: EventReader<StateTransitionEvent<DrawMethod>>,
+    mut reader: MessageReader<StateTransitionEvent<DrawMethod>>,
     query: Query<Entity, With<TheObject>>,
 ) {
     for event in reader.read() {
@@ -278,7 +278,7 @@ fn change_mode(
 
 fn change_shape(
     mut commands: Commands,
-    mut reader: EventReader<StateTransitionEvent<DrawShape>>,
+    mut reader: MessageReader<StateTransitionEvent<DrawShape>>,
     query: Query<Entity, With<TheObject>>,
     shapes: Res<Shapes>,
 ) {
@@ -293,7 +293,7 @@ fn change_shape(
 
 fn change_orientation(
     mut commands: Commands,
-    mut reader: EventReader<StateTransitionEvent<DrawOrientation>>,
+    mut reader: MessageReader<StateTransitionEvent<DrawOrientation>>,
     query: Query<Entity, With<TheObject>>,
 ) {
     for event in reader.read() {

src/computed.rs

@@ -1,4 +1,4 @@
-use bevy::{ecs::query::QueryItem, prelude::*, render::view::RenderLayers};
+use bevy::{camera::visibility::RenderLayers, ecs::query::QueryItem, prelude::*};
 
 use crate::{
     pipeline_key::ComputedOutlineKey,
@@ -215,7 +215,7 @@ fn update_computed_outline(
         fallback_layers,
         alpha_mask,
         warm_up,
-    ): QueryItem<'_, OutlineComponents>,
+    ): QueryItem<'_, '_, OutlineComponents>,
     parent_computed: Option<&ComputedInternal>,
     parent_entity: Option<Entity>,
     force_update: bool,

src/flood/bounds.rs

@@ -1,9 +1,9 @@
+use bevy::camera::primitives::Aabb;
+use bevy::camera::Viewport;
 use bevy::ecs::component::Component;
 use bevy::math::{Affine3A, Mat4, UVec2, Vec4Swizzles};
 use bevy::prelude::*;
-use bevy::render::camera::Viewport;
 use bevy::render::extract_component::ExtractComponent;
-use bevy::render::primitives::Aabb;
 
 use crate::computed::ComputedOutline;
 use crate::uniforms::DrawMode;

src/flood/compose_output.rs

@@ -1,5 +1,5 @@
 use bevy::{
-    core_pipeline::fullscreen_vertex_shader::fullscreen_shader_vertex_state,
+    core_pipeline::FullscreenShader,
     platform::collections::HashMap,
     prelude::*,
     render::{
@@ -84,17 +84,18 @@ impl ComposeOutputPipeline {
     pub(crate) fn get_pipeline(
         &mut self,
         pipeline_cache: &PipelineCache,
+        fullscreen_shader: &FullscreenShader,
         key: ViewPipelineKey,
     ) -> CachedRenderPipelineId {
         *self.pipeline_cache.entry(key).or_insert_with(|| {
             pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
                 label: Some("outline_flood_compose_output_pipeline".into()),
                 layout: vec![self.layout.clone()],
-                vertex: fullscreen_shader_vertex_state(),
+                vertex: fullscreen_shader.to_vertex_state(),
                 fragment: Some(FragmentState {
                     shader: COMPOSE_OUTPUT_SHADER_HANDLE,
                     shader_defs: vec![],
-                    entry_point: "fragment".into(),
+                    entry_point: None,
                     targets: vec![Some(ColorTargetState {
                         format: if key.hdr_format() {
                             ViewTarget::TEXTURE_FORMAT_HDR
@@ -134,11 +135,13 @@ pub(crate) fn prepare_compose_output_pass(
     mut commands: Commands,
     query: Query<(Entity, &ExtractedView, &Msaa), With<OutlineViewUniform>>,
     pipeline_cache: Res<PipelineCache>,
+    fullscreen_shader: Res<FullscreenShader>,
     mut compose_output_pipeline: ResMut<ComposeOutputPipeline>,
 ) {
     for (entity, view, msaa) in query.iter() {
         let pipeline_id = compose_output_pipeline.get_pipeline(
             &pipeline_cache,
+            &fullscreen_shader,
             ViewPipelineKey::new()
                 .with_msaa(*msaa)
                 .with_hdr_format(view.hdr),

src/flood/flood_init.rs

@@ -1,11 +1,13 @@
 use std::ops::Range;
 
+use bevy::camera::visibility::RenderLayers;
+use bevy::camera::Viewport;
 use bevy::prelude::*;
-use bevy::render::camera::{ExtractedCamera, Viewport};
+use bevy::render::camera::ExtractedCamera;
 use bevy::render::mesh::allocator::MeshAllocator;
 use bevy::render::render_phase::{DrawFunctions, PhaseItemExtraIndex, ViewSortedRenderPhases};
 use bevy::render::sync_world::MainEntity;
-use bevy::render::view::{ExtractedView, RenderLayers};
+use bevy::render::view::ExtractedView;
 use bevy::render::{
     render_phase::SortedRenderPhase,
     render_resource::{
@@ -64,9 +66,9 @@ pub(crate) fn queue_flood_meshes(
         };
         let viewport = camera.viewport.as_ref().unwrap_or(&fallback_viewport);
 
-        let clip_from_world = view.clip_from_world.unwrap_or_else(|| {
-            view.clip_from_view * view.world_from_view.compute_matrix().inverse()
-        });
+        let clip_from_world = view
+            .clip_from_world
+            .unwrap_or_else(|| view.clip_from_view * view.world_from_view.to_matrix().inverse());
 
         let rangefinder = OutlineRangefinder::new(view);
 
@@ -162,6 +164,7 @@ impl<'w> FloodInitPass<'w> {
 
         let color_attachment = RenderPassColorAttachment {
             view: &output.default_view,
+            depth_slice: None,
             resolve_target: None,
             ops: Operations {
                 load: LoadOp::Clear(wgpu_types::Color {

src/flood/jump_flood.rs

@@ -1,5 +1,5 @@
 use bevy::{
-    core_pipeline::fullscreen_vertex_shader::fullscreen_shader_vertex_state,
+    core_pipeline::FullscreenShader,
     prelude::*,
     render::{
         render_resource::{
@@ -53,17 +53,18 @@ impl FromWorld for JumpFloodPipeline {
 
         let sampler = render_device.create_sampler(&SamplerDescriptor::default());
 
+        let fullscreen_shader = world.resource::<FullscreenShader>().to_vertex_state();
         let pipeline_id =
             world
                 .resource_mut::<PipelineCache>()
                 .queue_render_pipeline(RenderPipelineDescriptor {
                     label: Some("outline_jump_flood_pipeline".into()),
                     layout: vec![layout.clone()],
-                    vertex: fullscreen_shader_vertex_state(),
+                    vertex: fullscreen_shader,
                     fragment: Some(FragmentState {
                         shader: JUMP_FLOOD_SHADER_HANDLE,
                         shader_defs: vec![],
-                        entry_point: "fragment".into(),
+                        entry_point: None,
                         targets: vec![Some(ColorTargetState {
                             format: TextureFormat::Rgba16Float,
                             blend: None,
@@ -137,6 +138,7 @@ impl<'w> JumpFloodPass<'w> {
             label: Some("outline_jump_flood_pass"),
             color_attachments: &[Some(RenderPassColorAttachment {
                 view: &output.default_view,
+                depth_slice: None,
                 resolve_target: None,
                 ops: Operations::default(),
             })],